Generates the nginx rules for prerendered pages

Pages now map to their html file, other forms get one redirect, unknown URLs
get a real 404 and responses are compressed. A browser-free test suite runs the
rules against a real nginx, in CI only so far.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
2026-11-01 03:00:07 +01:00
co-authored by Claude Opus 5.5
parent 4f32042410
commit 33334b889d
16 changed files with 1389 additions and 36 deletions
+175
View File
@@ -0,0 +1,175 @@
import fc from 'fast-check';
import { describe, expect, it } from 'vitest';
import {
hostilePath,
pageVariant,
unknownPath,
} from '../src/test/urlArbitraries';
import {
canonicalRedirect,
escapeRegex,
pagePaths,
redirectNames,
stripTrailingSlashes,
variantPattern,
} from './canonicalUrls';
// Wat de resolver per stap doet: eerst de paginavariant, anders de slashes
const hop = (path: string) =>
canonicalRedirect(path) ?? stripTrailingSlashes(path);
describe('pagePaths', () => {
it('begint met de beginpagina en bevat elke andere pagina eenmaal', () => {
expect(pagePaths[0]).toBe('/');
expect(new Set(pagePaths).size).toBe(pagePaths.length);
expect(redirectNames).toEqual(pagePaths.slice(1));
});
});
describe('canonicalRedirect', () => {
it.each([
['/over-mij/', '/over-mij'],
['/over-mij///', '/over-mij'],
['/over-mij.html', '/over-mij'],
['/soorten-fotoshoots/', '/soorten-fotoshoots'],
['/soorten-fotoshoots/newborn.html', '/soorten-fotoshoots/newborn'],
['/index', '/'],
['/index.html', '/'],
['/index/', '/'],
['/Over-Mij', '/over-mij'],
['/OVER-MIJ.HTML', '/over-mij'],
['/Over-Mij/', '/over-mij'],
['/Index.HTML//', '/'],
])('%s gaat naar %s', (path, target) => {
expect(canonicalRedirect(path)).toBe(target);
});
it.each([
'/',
'/over-mij',
'/soorten-fotoshoots/newborn',
'/onbekend',
'/Onbekend',
'/onbekend/',
'/x.html',
'/404',
'/404.html',
'/assets',
'/assets/',
'/over-mij/extra',
'',
])('laat %s met rust', (path) => {
expect(canonicalRedirect(path)).toBeUndefined();
});
it('P-HST-02: elke variant van een bekende pagina gaat naar het canonieke pad (invariant)', () => {
fc.assert(
fc.property(pageVariant, (variant) => {
const name = variant
.toLowerCase()
.replace(/\/+$/, '')
.replace(/\.html$/, '');
const canonical = name === '/index' ? '/' : name;
const target = canonicalRedirect(variant);
// De canonieke vorm zelf blijft staan
expect(target).toBe(
variant === canonical ? undefined : canonical,
);
}),
);
});
it('P-HST-03: het doel is een dekpunt en een variant heeft hooguit twee stappen nodig (idempotent)', () => {
fc.assert(
fc.property(pageVariant, (variant) => {
const target = canonicalRedirect(variant) ?? variant;
expect(canonicalRedirect(target)).toBeUndefined();
expect(stripTrailingSlashes(target)).toBeUndefined();
}),
);
fc.assert(
fc.property(
unknownPath,
fc.integer({ min: 0, max: 3 }),
(path, slashes) => {
const first = hop(path + '/'.repeat(slashes));
// Na de eerste stap is er niets meer te doen
expect(first === undefined ? undefined : hop(first)).toBe(
undefined,
);
},
),
);
});
it('P-HST-04: een doel begint met een slash, nooit met // of /\\, en is een bekende pagina (invariant)', () => {
const check = (path: string) => {
const target = canonicalRedirect(path);
if (target === undefined) return;
expect(pagePaths).toContain(target);
expect(target.startsWith('/')).toBe(true);
expect(target.startsWith('//')).toBe(false);
expect(target.startsWith('/\\')).toBe(false);
// eslint-disable-next-line no-control-regex
expect(target).not.toMatch(/[\u0000-\u001f\u007f]/);
};
fc.assert(fc.property(pageVariant, check));
fc.assert(fc.property(hostilePath, check));
});
});
describe('stripTrailingSlashes', () => {
it.each([
['/onbekend/', '/onbekend'],
['/onbekend///', '/onbekend'],
['/assets/', '/assets'],
['/a/b/', '/a/b'],
['//', '/'],
])('%s wordt %s', (path, stripped) => {
expect(stripTrailingSlashes(path)).toBe(stripped);
});
it.each(['/', '', '/onbekend', '/a/b'])('laat %s met rust', (path) => {
expect(stripTrailingSlashes(path)).toBeUndefined();
});
it.each([
'//evil.example/',
'/\\evil.example/',
'/over-mij\r\nSet-Cookie: x=1/',
'/over-mij\0/',
])('geeft geen doel voor het gevaarlijke pad %j (BR-HST-06)', (path) => {
expect(stripTrailingSlashes(path)).toBeUndefined();
});
it('P-HST-04: een doel is veilig, ook voor vijandige paden (invariant)', () => {
fc.assert(
fc.property(hostilePath, (path) => {
const target = stripTrailingSlashes(path);
if (target === undefined) return;
expect(target.startsWith('/')).toBe(true);
expect(target.startsWith('//')).toBe(false);
expect(target.startsWith('/\\')).toBe(false);
expect(target.endsWith('/') && target !== '/').toBe(false);
// eslint-disable-next-line no-control-regex
expect(target).not.toMatch(/[\u0000-\u001f\u007f]/);
}),
);
});
});
describe('variantPattern en escapeRegex', () => {
it('zet de naam, een optionele .html en slashes in het patroon', () => {
expect(variantPattern('/over-mij')).toBe('over-mij(?:\\.html)?/*');
expect(variantPattern('/')).toBe('index(?:\\.html)?/*');
expect(variantPattern('/soorten-fotoshoots/newborn')).toBe(
'soorten-fotoshoots/newborn(?:\\.html)?/*',
);
});
it('escapet tekens met een betekenis in een reguliere expressie', () => {
expect(escapeRegex('a.b*c(d)|e[f]\\')).toBe(
'a\\.b\\*c\\(d\\)\\|e\\[f\\]\\\\',
);
});
});
+63
View File
@@ -0,0 +1,63 @@
// De URL-regels voor bekende pagina's (BR-HST-03, 04, 06) op één plek: de
// previewserver gebruikt de functies, de generatoren voor nginx en IIS halen
// er de patronen en de paginalijst uit. Zo kennen alle drie dezelfde pagina's
// en dezelfde varianten. Puur: geen DOM en geen I/O.
import sitePages from '../src/sitePages.ts';
// '/' staat vooraan; de rest in de volgorde van het register
export const pagePaths: readonly string[] = Object.keys(sitePages);
// Alle pagina's behalve '/': die krijgen een eigen regel in nginx en IIS
export const redirectNames: readonly string[] = pagePaths.filter(
(path) => path !== '/',
);
// Naam van de beginpagina onder een andere naam (BR-HST-04)
const INDEX_NAME = 'index';
export const escapeRegex = (text: string): string =>
text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
// Bron van het hoofdletterongevoelige patroon voor alle varianten van één
// pagina, zonder voorste slash of ankers: de naam, eventueel .html, eventueel
// slashes aan het eind. Voor '/' is de naam 'index'. nginx zet er '^/' voor,
// IIS '^'. De canonieke vorm zelf valt er ook onder; de generatoren sluiten
// die uit.
export function variantPattern(path: string): string {
const name = path === '/' ? INDEX_NAME : path.replace(/^\//, '');
return `${escapeRegex(name)}(?:\\.html)?/*`;
}
const variantMatchers = pagePaths.map(
(path) => [new RegExp(`^/${variantPattern(path)}$`, 'i'), path] as const,
);
// Het canonieke doel als het (gedecodeerde) pad een afwijkende vorm van een
// bekende pagina is, anders undefined. Onbekende paden en /404 blijven
// onaangeroerd. Het doel komt altijd uit de constante paginalijst.
export function canonicalRedirect(decodedPath: string): string | undefined {
for (const [matcher, canonical] of variantMatchers) {
if (matcher.test(decodedPath)) {
return decodedPath === canonical ? undefined : canonical;
}
}
return undefined;
}
// Stuurcodes en DEL in een doel zouden een header kunnen splitsen
// eslint-disable-next-line no-control-regex
const CONTROL_CHARACTERS = /[\u0000-\u001f\u007f]/;
// Het pad zonder slashes aan het eind (BR-HST-03), voor elk pad langer dan één
// teken dat op een slash eindigt. Een doel dat met '//' of '/\' begint (een
// ander domein voor de browser) of stuurcodes bevat wordt niet teruggegeven
// (BR-HST-06): de aanroeper behandelt zo'n pad als onbekend.
export function stripTrailingSlashes(decodedPath: string): string | undefined {
if (decodedPath.length < 2 || !decodedPath.endsWith('/')) return undefined;
const stripped = decodedPath.replace(/\/+$/, '') || '/';
if (stripped.startsWith('//') || stripped.startsWith('/\\')) {
return undefined;
}
if (CONTROL_CHARACTERS.test(stripped)) return undefined;
return stripped;
}
+91
View File
@@ -0,0 +1,91 @@
// Eén lijst met bestandstypen voor de previewserver (Content-Type en welke
// bestanden gzip krijgen), de gzip_types van nginx en de MIME-pins van IIS
// (BR-HST-11). Een test controleert dat ze overeenkomen.
export interface FileType {
extension: string;
// MIME-types zonder parameters, zoals nginx en IIS ze kennen
mimeTypes: string[];
// Exacte Content-Type van de previewserver
previewContentType: string;
}
// Tekst: wordt gecomprimeerd. nginx 1.24 kent .js als application/javascript,
// vanaf 1.25.2 als text/javascript (de Pi draait 1.30.6): gzip_types moet
// beide bevatten. Zo ook .xml.
export const compressibleTypes: readonly FileType[] = [
{
extension: '.html',
mimeTypes: ['text/html'],
previewContentType: 'text/html; charset=utf-8',
},
{
extension: '.js',
mimeTypes: ['text/javascript', 'application/javascript'],
previewContentType: 'text/javascript; charset=utf-8',
},
{
extension: '.css',
mimeTypes: ['text/css'],
previewContentType: 'text/css; charset=utf-8',
},
{
extension: '.svg',
mimeTypes: ['image/svg+xml'],
previewContentType: 'image/svg+xml',
},
{
extension: '.json',
mimeTypes: ['application/json'],
previewContentType: 'application/json; charset=utf-8',
},
{
extension: '.xml',
mimeTypes: ['text/xml', 'application/xml'],
previewContentType: 'application/xml; charset=utf-8',
},
{
extension: '.txt',
mimeTypes: ['text/plain'],
previewContentType: 'text/plain; charset=utf-8',
},
];
// Al gecomprimeerd: niet nog eens comprimeren
export const plainTypes: readonly FileType[] = [
{
extension: '.png',
mimeTypes: ['image/png'],
previewContentType: 'image/png',
},
{
extension: '.jpg',
mimeTypes: ['image/jpeg'],
previewContentType: 'image/jpeg',
},
{
extension: '.webp',
mimeTypes: ['image/webp'],
previewContentType: 'image/webp',
},
{
extension: '.woff2',
mimeTypes: ['font/woff2'],
previewContentType: 'font/woff2',
},
{
extension: '.ico',
mimeTypes: ['image/x-icon'],
previewContentType: 'image/x-icon',
},
];
export const compressibleExtensions: ReadonlySet<string> = new Set(
compressibleTypes.map((type) => type.extension),
);
// Voor gzip_types: uniek, zonder text/html (nginx comprimeert dat altijd)
export function gzipMimeTypes(): string[] {
const types = compressibleTypes.flatMap((type) => type.mimeTypes);
return [...new Set(types)].filter((type) => type !== 'text/html');
}
+9 -3
View File
@@ -59,7 +59,10 @@ describe('serverconfiguratie', () => {
const nginx = nginxTestConf();
expect(nginx).toContain('X-Robots-Tag "noindex, nofollow"');
expect(nginx).toContain('Disallow: /');
expect(nginx).toContain('try_files $uri $uri/ /index.html =404;');
// Geen SPA-fallback (BR-HST-02) en geen mapdoorverwijzing (BR-HST-07)
expect(nginx).toContain('try_files $uri $uri.html =404;');
expect(nginx).not.toMatch(/try_files[^;]*\$uri[^;]*\/index\.html/);
expect(nginx).not.toContain('$uri/');
});
it('het testblok claimt nooit de standaardserver (WordPress op dezelfde Pi)', () => {
@@ -87,8 +90,11 @@ describe('serverconfiguratie', () => {
it('elk nginx location-blok herhaalt de security headers', () => {
// nginx erft add_header niet als een location er zelf een zet
const blocks = nginxTestConf().split('location ').slice(1);
expect(blocks).toHaveLength(3);
const blocks = nginxTestConf()
.split(/^ *location /m)
.slice(1);
// robots.txt, 404, 404.html, assets, de beginpagina en de rest
expect(blocks).toHaveLength(6);
for (const block of blocks) {
expect(block).toContain('Content-Security-Policy');
}
+108 -19
View File
@@ -3,6 +3,8 @@
// dev- en preview-server. Zo bestaat de headerset maar op één plek.
// Schrijven: `pnpm server-config`. Een test controleert dat de bestanden in
// deploy/ gelijk zijn aan wat deze functies opleveren.
import { gzipMimeTypes } from './compressibleTypes.ts';
import { redirectNames, variantPattern } from './canonicalUrls.ts';
import { securityHeaders } from './securityHeaders.ts';
const generatedNotice =
@@ -87,55 +89,142 @@ ${headers}
// nginx (test): dezelfde headers, plus noindex zodat de testsite nooit in
// zoekmachines komt. nginx erft add_header niet als een location er zelf een
// zet, daarom staan de headers in elk location-blok.
export function nginxTestConf(): string {
const headers = [
// zet, daarom staan de headers in elk location-blok, elk met de volledige set
// en zijn eigen Cache-Control. De URL-regels (BR-HST-01 tot 08) komen uit de
// paginalijst, zodat nginx, IIS en de previewserver dezelfde pagina's kennen.
//
// listen en root zijn instelbaar voor de serverregeltests (e2e/serverRules),
// die een echte nginx op een vrije poort met een tijdelijke map starten.
export function nginxTestConf(
options: { listen?: string; root?: string } = {},
): string {
const { listen = '80', root = '/var/www/html/andreaslop-test' } = options;
const securityLines = [
...Object.entries(securityHeaders('production')).map(
([name, value]) => `add_header ${name} "${value}" always;`,
),
'add_header X-Robots-Tag "noindex, nofollow" always;',
];
const block = (indent: string, extra: string[] = []) =>
[...headers, ...extra].map((line) => indent + line).join('\n');
const noCache = 'add_header Cache-Control "no-cache" always;';
const immutable =
'add_header Cache-Control "public, max-age=31536000, immutable" always;';
// Eén bron voor alle blokken met headers: de volledige set plus precies
// één Cache-Control, zodat geen enkel blok een header kwijtraakt
const block = (indent: string, cacheControl: string | undefined) =>
[...securityLines, ...(cacheControl ? [cacheControl] : [])]
.map((line) => indent + line)
.join('\n');
// Exacte canonieke vormen winnen van de reguliere expressies eronder, dus
// het canonieke pad zelf wordt nooit doorverwezen. Geen regel mag /404 of
// /404.html raken: error_page draait de server-regels opnieuw met
// $uri=/404.html en zou van de 404-pagina een redirect maken.
const canonicalEntries = redirectNames.map((path) => ` ${path} "";`);
const variantEntries = [
` ~*^/${variantPattern('/')}$ /;`,
...redirectNames.map(
(path) => ` ~*^/${variantPattern(path)}$ ${path};`,
),
];
return `# ${generatedNotice}
# Test-omgeving op de Raspberry Pi, achter de reverse-proxy-Pi (die TLS afhandelt
# met certbot). De proxy moet de Host-header doorgeven (proxy_set_header Host
# $host), anders kiest nginx hier het standaardblok (WordPress).
# Test-omgeving op de Raspberry Pi (hosting-Pi), achter de reverse-proxy-Pi
# (die TLS afhandelt met certbot). Installatie: als
# /etc/nginx/conf.d/andreaslop-test.conf; nginx.conf laadt conf.d binnen
# http {}, er is geen sites-enabled. De globale nginx.conf hoeft niet te
# veranderen: dit bestand brengt zijn eigen gzip-instellingen mee, want op de
# Pi staat gzip nergens aan. Ze werken ook als de proxy HTTP/1.0 praat.
# De proxy moet de Host-header doorgeven (proxy_set_header Host $host); het
# blok wordt gekozen op server_name. Een onbekende host krijgt een 444 van
# het standaardblok /etc/nginx/conf.d/00-default.conf.
# Eigen server-blok naast de WordPress-site: bewust geen default_server, zodat
# dit blok alleen de testhostname beantwoordt.
# Pas server_name en root aan aan de server; de rest komt uit de generator.
# Bekende pagina's in een afwijkende vorm (hoofdletters, .html, /index,
# slashes aan het eind) gaan met één 301 naar het canonieke pad. De waarden
# zijn constanten uit de paginalijst, nooit afgeleid van het verzoek.
map $uri $andreaslop_canonical {
default "";
${canonicalEntries.join('\n')}
${variantEntries.join('\n')}
}
server {
listen 80;
listen ${listen};
server_name test.andreaslop.nl;
root /var/www/html/andreaslop-test;
index index.html;
root ${root};
# Achter de reverse proxy: doorverwijzingen relatief houden, anders stuurt
# nginx naar zijn eigen http://-adres in plaats van de https-hostname
absolute_redirect off;
${block(' ', ['add_header Cache-Control "no-cache" always;'])}
# Geen index-directive en geen mappen tonen: index zou intern naar
# /index.html gaan, dat hierboven naar / doorverwijst (lus)
autoindex off;
${block(' ', noCache)}
# Eigen compressie (de Pi heeft geen gzip aan). text/html is altijd aan.
gzip on;
gzip_vary on;
gzip_proxied any;
gzip_http_version 1.0;
gzip_comp_level 5;
gzip_min_length 256;
gzip_types ${gzipMimeTypes().join(' ')};
# Alleen return in een if is veilig. Het doel komt uit de map hierboven.
if ($andreaslop_canonical) {
return 301 $andreaslop_canonical$is_args$args;
}
# Slashes aan het eind van elk ander pad weg. Bewust rewrite en geen
# return met $uri: de serverregeltests controleren dat een regeleinde of
# backslash in het pad nooit in een Location terechtkomt.
rewrite ^/(.+?)/+$ /$1 permanent;
# Onbekend: de 404-pagina met status 404 (geen = achter de code)
error_page 404 /404.html;
# Testsite nooit indexeren
location = /robots.txt {
${block(' ')}
${block(' ', noCache)}
default_type text/plain;
return 200 "User-agent: *\\nDisallow: /\\n";
}
# Zonder dit zou $uri.html de pagina met 200 tonen
location = /404 {
${block(' ', noCache)}
return 404;
}
# Alleen bereikbaar via error_page; een direct verzoek geeft 404
location = /404.html {
internal;
${block(' ', noCache)}
}
# Bestanden met een hash in de naam: lang cachen
location /assets/ {
${block(' ', ['add_header Cache-Control "public, max-age=31536000, immutable" always;'])}
${block(' ', immutable)}
try_files $uri =404;
}
# SPA-fallback: onbekende paden krijgen index.html (de router toont de 404).
# =404 aan het eind: zonder index.html (lege map) een 404 in plaats van een
# doorverwijzingslus die nginx als 500 afbreekt
# Geen index-directive: de beginpagina staat hier uitdrukkelijk
location = / {
${block(' ', noCache)}
try_files /index.html =404;
}
# Paginabestand zonder .html. $uri zonder slash is alleen een bestand, dus
# een map naast soorten-fotoshoots.html wordt overgeslagen (BR-HST-07).
# Nooit een slash achter de variabele zetten: dat geeft nginx' eigen
# mapdoorverwijzing.
location / {
${block(' ', ['add_header Cache-Control "no-cache" always;'])}
try_files $uri $uri/ /index.html =404;
${block(' ', noCache)}
try_files $uri $uri.html =404;
}
}
`;