Adds a preview server that follows the real server rules
Lighthouse and the browser tests need a real 404 status, the .html mapping and the production headers, which vite preview does not give. It is not wired into the scripts yet. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
@@ -0,0 +1,522 @@
|
||||
import { spawn } from 'node:child_process';
|
||||
import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
|
||||
import { request, type Server } from 'node:http';
|
||||
import { createServer } from 'node:net';
|
||||
import { tmpdir } from 'node:os';
|
||||
import { dirname, join, posix, win32 } from 'node:path';
|
||||
import { fileURLToPath } from 'node:url';
|
||||
import fc from 'fast-check';
|
||||
import { afterEach, describe, expect, it } from 'vitest';
|
||||
import {
|
||||
anyRequestPath,
|
||||
dottedFileName,
|
||||
existingFiles,
|
||||
existsIn,
|
||||
pageName,
|
||||
} from '../src/test/requestArbitraries';
|
||||
import { securityHeaders } from './securityHeaders';
|
||||
import {
|
||||
contentTypeOf,
|
||||
resolveRequest,
|
||||
startPreviewServer,
|
||||
} from './previewServer';
|
||||
|
||||
const NOT_FOUND = { file: '404.html', status: 404 };
|
||||
const FILES = new Set([
|
||||
'index.html',
|
||||
'404.html',
|
||||
'over-mij.html',
|
||||
'soorten-fotoshoots.html',
|
||||
'soorten-fotoshoots/newborn.html',
|
||||
'assets/app.js',
|
||||
'favicon.png',
|
||||
]);
|
||||
const resolveIn = (path: string) => resolveRequest(path, existsIn(FILES));
|
||||
|
||||
describe('resolveRequest', () => {
|
||||
it('geeft index.html voor /', () => {
|
||||
expect(resolveIn('/')).toEqual({ file: 'index.html', status: 200 });
|
||||
});
|
||||
|
||||
it('geeft het paginabestand voor een pad zonder punt als dat bestaat', () => {
|
||||
expect(resolveIn('/over-mij')).toEqual({
|
||||
file: 'over-mij.html',
|
||||
status: 200,
|
||||
});
|
||||
expect(resolveIn('/soorten-fotoshoots/newborn')).toEqual({
|
||||
file: 'soorten-fotoshoots/newborn.html',
|
||||
status: 200,
|
||||
});
|
||||
});
|
||||
|
||||
it('geeft 404.html met 404 voor een pad zonder bestaande pagina', () => {
|
||||
expect(resolveIn('/nope')).toEqual(NOT_FOUND);
|
||||
expect(resolveIn('/soorten-fotoshoots/nope')).toEqual(NOT_FOUND);
|
||||
});
|
||||
|
||||
it('behandelt een laatste segment met een punt als bestandsverzoek', () => {
|
||||
expect(resolveIn('/assets/app.js')).toEqual({
|
||||
file: 'assets/app.js',
|
||||
status: 200,
|
||||
});
|
||||
expect(resolveIn('/favicon.png')).toEqual({
|
||||
file: 'favicon.png',
|
||||
status: 200,
|
||||
});
|
||||
expect(resolveIn('/over-mij.html')).toEqual({
|
||||
file: 'over-mij.html',
|
||||
status: 200,
|
||||
});
|
||||
expect(resolveIn('/assets/weg.js')).toEqual(NOT_FOUND);
|
||||
});
|
||||
|
||||
it('zoekt geen paginabestand achter een bestandsverzoek', () => {
|
||||
// /over-mij.x is een bestand, geen pagina
|
||||
expect(resolveIn('/over-mij.x')).toEqual(NOT_FOUND);
|
||||
});
|
||||
|
||||
it('decodeert één keer', () => {
|
||||
expect(resolveIn('/over%2Dmij')).toEqual({
|
||||
file: 'over-mij.html',
|
||||
status: 200,
|
||||
});
|
||||
// Dubbel gecodeerd wordt na één keer een gewone (onbekende) naam
|
||||
expect(resolveIn('/over%252Dmij')).toEqual(NOT_FOUND);
|
||||
});
|
||||
|
||||
it('weigert een pad dat niet decodeert', () => {
|
||||
expect(resolveIn('/%')).toEqual(NOT_FOUND);
|
||||
expect(resolveIn('/%zz')).toEqual(NOT_FOUND);
|
||||
expect(resolveIn('/%c0%af')).toEqual(NOT_FOUND);
|
||||
});
|
||||
|
||||
it('weigert NUL en backslash, ook gecodeerd', () => {
|
||||
expect(resolveIn('/over-mij%00')).toEqual(NOT_FOUND);
|
||||
expect(resolveIn('/over-mij\0.html')).toEqual(NOT_FOUND);
|
||||
expect(resolveIn('/assets\\app.js')).toEqual(NOT_FOUND);
|
||||
expect(resolveIn('/assets%5Capp.js')).toEqual(NOT_FOUND);
|
||||
});
|
||||
|
||||
it('weigert .. in elke codering', () => {
|
||||
for (const path of [
|
||||
'/../index.html',
|
||||
'/assets/../index.html',
|
||||
'/%2e%2e/index.html',
|
||||
'/%2E%2E/index.html',
|
||||
'/assets/%2e%2e/index.html',
|
||||
'/..%2findex.html',
|
||||
'/assets%2f..%2findex.html',
|
||||
'/..',
|
||||
'/assets/..',
|
||||
]) {
|
||||
expect(resolveIn(path), path).toEqual(NOT_FOUND);
|
||||
}
|
||||
});
|
||||
|
||||
it('weigert . en segmenten van alleen punten en spaties', () => {
|
||||
for (const path of [
|
||||
'/./index.html',
|
||||
'/assets/./app.js',
|
||||
'/...',
|
||||
'/.. ',
|
||||
]) {
|
||||
expect(resolveIn(path), path).toEqual(NOT_FOUND);
|
||||
}
|
||||
});
|
||||
|
||||
it('weigert een pad zonder voorste slash en een Windows-stationsletter', () => {
|
||||
expect(resolveIn('')).toEqual(NOT_FOUND);
|
||||
expect(resolveIn('index.html')).toEqual(NOT_FOUND);
|
||||
const drive = resolveRequest('/c:/windows/x.ini', () => true);
|
||||
expect(win32.isAbsolute(drive.file)).toBe(false);
|
||||
expect(drive).toEqual(NOT_FOUND);
|
||||
});
|
||||
|
||||
it('geeft 404 voor een dubbele slash', () => {
|
||||
expect(resolveIn('//over-mij')).toEqual(NOT_FOUND);
|
||||
expect(resolveIn('/assets//app.js')).toEqual(NOT_FOUND);
|
||||
});
|
||||
|
||||
describe('tussenregels uit BR-SRV-07', () => {
|
||||
it('geeft 404 voor een slash aan het eind, zonder redirect', () => {
|
||||
expect(resolveIn('/over-mij/')).toEqual(NOT_FOUND);
|
||||
expect(resolveIn('/soorten-fotoshoots/')).toEqual(NOT_FOUND);
|
||||
expect(resolveIn('/assets/')).toEqual(NOT_FOUND);
|
||||
});
|
||||
|
||||
it('antwoordt op /404 met 404.html en status 404, niet 200', () => {
|
||||
expect(resolveIn('/404')).toEqual(NOT_FOUND);
|
||||
});
|
||||
|
||||
it('serveert /404.html als bestand met 200 (BR-SRV-04)', () => {
|
||||
// Lighthouse weigert een 404-status en valt hierop terug
|
||||
expect(resolveIn('/404.html')).toEqual({
|
||||
file: '404.html',
|
||||
status: 200,
|
||||
});
|
||||
expect(resolveRequest('/404.html', () => false)).toEqual(NOT_FOUND);
|
||||
});
|
||||
|
||||
it('geeft /index en /index.html het bestand van /', () => {
|
||||
expect(resolveIn('/index')).toEqual({
|
||||
file: 'index.html',
|
||||
status: 200,
|
||||
});
|
||||
expect(resolveIn('/index.html')).toEqual({
|
||||
file: 'index.html',
|
||||
status: 200,
|
||||
});
|
||||
});
|
||||
|
||||
it('geeft nooit een redirect terug', () => {
|
||||
for (const path of ['/over-mij/', '/404', '/index', '/']) {
|
||||
expect(resolveIn(path)).not.toHaveProperty('redirect');
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
it('geeft index.html voor / ook als de bestandslijst leeg is', () => {
|
||||
expect(resolveRequest('/', () => false)).toEqual({
|
||||
file: 'index.html',
|
||||
status: 200,
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe('resolveRequest (eigenschappen)', () => {
|
||||
it('blijft binnen clientDir, voor elk pad (invariant, P16)', () => {
|
||||
fc.assert(
|
||||
fc.property(
|
||||
anyRequestPath,
|
||||
existingFiles,
|
||||
fc.boolean(),
|
||||
(path, files, everythingExists) => {
|
||||
const { file, status } = resolveRequest(
|
||||
path,
|
||||
everythingExists ? () => true : existsIn(files),
|
||||
);
|
||||
expect(file.split('/')).not.toContain('..');
|
||||
expect(file.startsWith('/')).toBe(false);
|
||||
expect(posix.isAbsolute(file)).toBe(false);
|
||||
expect(win32.isAbsolute(file)).toBe(false);
|
||||
expect(file).not.toContain('\\');
|
||||
expect(file).not.toContain('\0');
|
||||
// 404 hoort alleen bij de 404-pagina
|
||||
if (status === 404) expect(file).toBe('404.html');
|
||||
},
|
||||
),
|
||||
);
|
||||
});
|
||||
|
||||
it('kent / en /x en /bestand.ext zoals het model (oracle, P17)', () => {
|
||||
fc.assert(
|
||||
fc.property(
|
||||
existingFiles,
|
||||
pageName,
|
||||
fc.array(pageName, { maxLength: 2 }),
|
||||
dottedFileName,
|
||||
(files, name, dirs, dotted) => {
|
||||
const exists = existsIn(files);
|
||||
// Het model: wat bestaat is 200, de rest 404. Alleen het
|
||||
// pagina-pad /404 is 404 ook al bestaat 404.html; het
|
||||
// bestandsverzoek /404.html is 200.
|
||||
const expected = (file: string, isPage = false) =>
|
||||
files.has(file) && !(isPage && file === '404.html')
|
||||
? { file, status: 200 }
|
||||
: NOT_FOUND;
|
||||
|
||||
expect(resolveRequest('/', exists)).toEqual({
|
||||
file: 'index.html',
|
||||
status: 200,
|
||||
});
|
||||
|
||||
const page = [...dirs, name].join('/');
|
||||
expect(resolveRequest(`/${page}`, exists)).toEqual(
|
||||
expected(`${page}.html`, true),
|
||||
);
|
||||
|
||||
const asset = [...dirs, dotted].join('/');
|
||||
expect(resolveRequest(`/${asset}`, exists)).toEqual(
|
||||
expected(asset),
|
||||
);
|
||||
// Een bestand dat echt bestaat wordt altijd gevonden
|
||||
for (const file of files) {
|
||||
expect(resolveRequest(`/${file}`, exists)).toEqual({
|
||||
file,
|
||||
status: 200,
|
||||
});
|
||||
}
|
||||
},
|
||||
),
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
describe('contentTypeOf', () => {
|
||||
it('kiest het type op de extensie, hoofdletterongevoelig', () => {
|
||||
expect(contentTypeOf('a.html')).toBe('text/html; charset=utf-8');
|
||||
expect(contentTypeOf('a.JS')).toBe('text/javascript; charset=utf-8');
|
||||
expect(contentTypeOf('a.woff2')).toBe('font/woff2');
|
||||
expect(contentTypeOf('a.png')).toBe('image/png');
|
||||
expect(contentTypeOf('a.onbekend')).toBe('application/octet-stream');
|
||||
expect(contentTypeOf('geen-extensie')).toBe('application/octet-stream');
|
||||
});
|
||||
});
|
||||
|
||||
interface Answer {
|
||||
status: number;
|
||||
headers: Record<string, string | string[] | undefined>;
|
||||
body: string;
|
||||
}
|
||||
|
||||
// node:http in plaats van fetch: die laat het pad ongemoeid, ook '..'
|
||||
const ask = (port: number, path: string, method = 'GET'): Promise<Answer> =>
|
||||
new Promise((resolve, reject) => {
|
||||
const req = request(
|
||||
{ host: '127.0.0.1', port, path, method },
|
||||
(response) => {
|
||||
const chunks: Buffer[] = [];
|
||||
response.on('data', (chunk: Buffer) => chunks.push(chunk));
|
||||
response.on('end', () =>
|
||||
resolve({
|
||||
status: response.statusCode ?? 0,
|
||||
headers: response.headers,
|
||||
body: Buffer.concat(chunks).toString('utf8'),
|
||||
}),
|
||||
);
|
||||
},
|
||||
);
|
||||
req.on('error', reject);
|
||||
req.end();
|
||||
});
|
||||
|
||||
const tempDirs: string[] = [];
|
||||
const servers: Server[] = [];
|
||||
|
||||
afterEach(async () => {
|
||||
await Promise.all(
|
||||
servers
|
||||
.splice(0)
|
||||
.map((server) => new Promise((done) => server.close(done))),
|
||||
);
|
||||
for (const dir of tempDirs.splice(0)) {
|
||||
rmSync(dir, { recursive: true, force: true });
|
||||
}
|
||||
});
|
||||
|
||||
function siteDir(): string {
|
||||
const root = mkdtempSync(join(tmpdir(), 'preview-'));
|
||||
tempDirs.push(root);
|
||||
const clientDir = join(root, 'dist', 'client');
|
||||
mkdirSync(join(clientDir, 'assets'), { recursive: true });
|
||||
writeFileSync(join(clientDir, 'index.html'), '<p>home</p>');
|
||||
writeFileSync(join(clientDir, 'over-mij.html'), '<p>over mij</p>');
|
||||
writeFileSync(join(clientDir, '404.html'), '<p>niet gevonden</p>');
|
||||
writeFileSync(join(clientDir, 'assets', 'app.js'), 'boot()');
|
||||
// Buiten clientDir: mag nooit bereikbaar zijn
|
||||
writeFileSync(join(root, 'dist', 'geheim.txt'), 'geheim');
|
||||
return clientDir;
|
||||
}
|
||||
|
||||
async function serve(clientDir: string): Promise<number> {
|
||||
const server = await startPreviewServer(clientDir, 0);
|
||||
servers.push(server);
|
||||
const address = server.address();
|
||||
if (typeof address !== 'object' || !address) throw new Error('geen poort');
|
||||
return address.port;
|
||||
}
|
||||
|
||||
describe('startPreviewServer', () => {
|
||||
it('stuurt een pagina met 200, het type en no-cache', async () => {
|
||||
const port = await serve(siteDir());
|
||||
const answer = await ask(port, '/over-mij');
|
||||
expect(answer.status).toBe(200);
|
||||
expect(answer.body).toBe('<p>over mij</p>');
|
||||
expect(answer.headers['content-type']).toBe('text/html; charset=utf-8');
|
||||
expect(answer.headers['cache-control']).toBe('no-cache');
|
||||
});
|
||||
|
||||
it('stuurt een asset met het type van de extensie, zonder no-cache', async () => {
|
||||
const port = await serve(siteDir());
|
||||
const answer = await ask(port, '/assets/app.js?v=1#x');
|
||||
expect(answer.status).toBe(200);
|
||||
expect(answer.body).toBe('boot()');
|
||||
expect(answer.headers['content-type']).toBe(
|
||||
'text/javascript; charset=utf-8',
|
||||
);
|
||||
expect(answer.headers['cache-control']).toBeUndefined();
|
||||
});
|
||||
|
||||
it('zet de securityheaders op 200 en op 404', async () => {
|
||||
const port = await serve(siteDir());
|
||||
const expected = securityHeaders('production');
|
||||
for (const path of ['/', '/nope']) {
|
||||
const { headers } = await ask(port, path);
|
||||
for (const [name, value] of Object.entries(expected)) {
|
||||
expect(headers[name.toLowerCase()], `${path} ${name}`).toBe(
|
||||
value,
|
||||
);
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
it('antwoordt op een onbekend pad met de 404-pagina en status 404', async () => {
|
||||
const port = await serve(siteDir());
|
||||
const answer = await ask(port, '/nope');
|
||||
expect(answer.status).toBe(404);
|
||||
expect(answer.body).toBe('<p>niet gevonden</p>');
|
||||
expect(answer.headers['content-type']).toBe('text/html; charset=utf-8');
|
||||
});
|
||||
|
||||
it('antwoordt op /404 met status 404', async () => {
|
||||
const port = await serve(siteDir());
|
||||
expect((await ask(port, '/404')).status).toBe(404);
|
||||
const file = await ask(port, '/404.html');
|
||||
expect(file.status).toBe(200);
|
||||
expect(file.body).toBe('<p>niet gevonden</p>');
|
||||
});
|
||||
|
||||
it('geeft 405 op POST, PUT en DELETE, met securityheaders', async () => {
|
||||
const port = await serve(siteDir());
|
||||
for (const method of ['POST', 'PUT', 'DELETE']) {
|
||||
const answer = await ask(port, '/', method);
|
||||
expect(answer.status, method).toBe(405);
|
||||
expect(answer.headers.allow).toBe('GET, HEAD');
|
||||
expect(answer.headers['content-security-policy']).toBeDefined();
|
||||
}
|
||||
});
|
||||
|
||||
it('stuurt bij HEAD de headers en lengte maar geen inhoud', async () => {
|
||||
const port = await serve(siteDir());
|
||||
const answer = await ask(port, '/over-mij', 'HEAD');
|
||||
expect(answer.status).toBe(200);
|
||||
expect(answer.body).toBe('');
|
||||
expect(answer.headers['content-length']).toBe(
|
||||
String('<p>over mij</p>'.length),
|
||||
);
|
||||
expect(answer.headers['content-type']).toBe('text/html; charset=utf-8');
|
||||
expect((await ask(port, '/nope', 'HEAD')).status).toBe(404);
|
||||
});
|
||||
|
||||
it('komt met geen enkele traversal buiten clientDir (misbruikgeval)', async () => {
|
||||
const port = await serve(siteDir());
|
||||
for (const path of [
|
||||
'/../geheim.txt',
|
||||
'/%2e%2e/geheim.txt',
|
||||
'/..%2fgeheim.txt',
|
||||
'/assets/../../geheim.txt',
|
||||
'/..%5cgeheim.txt',
|
||||
'/%2e%2e%5cgeheim.txt',
|
||||
'/geheim.txt%00.html',
|
||||
]) {
|
||||
const answer = await ask(port, path);
|
||||
expect(answer.status, path).toBe(404);
|
||||
expect(answer.body, path).not.toContain('geheim');
|
||||
}
|
||||
});
|
||||
|
||||
it('geeft een gewone 404 als clientDir geen 404.html heeft', async () => {
|
||||
const clientDir = siteDir();
|
||||
rmSync(join(clientDir, '404.html'));
|
||||
const port = await serve(clientDir);
|
||||
const answer = await ask(port, '/nope');
|
||||
expect(answer.status).toBe(404);
|
||||
expect(answer.body).toBe('Not Found');
|
||||
const head = await ask(port, '/nope', 'HEAD');
|
||||
expect(head.status).toBe(404);
|
||||
expect(head.body).toBe('');
|
||||
});
|
||||
|
||||
it('weigert te starten op een bezette poort', async () => {
|
||||
const port = await serve(siteDir());
|
||||
await expect(startPreviewServer(siteDir(), port)).rejects.toThrow(
|
||||
/EADDRINUSE/,
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
describe('previewServer als opdrachtregel', () => {
|
||||
const script = join(
|
||||
dirname(fileURLToPath(import.meta.url)),
|
||||
'previewServer.ts',
|
||||
);
|
||||
const children: ReturnType<typeof spawn>[] = [];
|
||||
|
||||
afterEach(() => {
|
||||
for (const child of children.splice(0)) child.kill();
|
||||
});
|
||||
|
||||
const start = (...args: string[]) => {
|
||||
const child = spawn(process.execPath, [script, ...args], {
|
||||
stdio: ['ignore', 'pipe', 'pipe'],
|
||||
});
|
||||
children.push(child);
|
||||
let stdout = '';
|
||||
let stderr = '';
|
||||
child.stdout.on('data', (chunk) => (stdout += chunk));
|
||||
child.stderr.on('data', (chunk) => (stderr += chunk));
|
||||
const exited = new Promise<number | null>((done) =>
|
||||
child.on('exit', done),
|
||||
);
|
||||
const ready = new Promise<string>((done) => {
|
||||
const check = () => {
|
||||
if (stdout.includes('Local')) done(stdout);
|
||||
};
|
||||
child.stdout.on('data', check);
|
||||
exited.then(() => done(stdout));
|
||||
});
|
||||
return { ready, exited, stderr: () => stderr };
|
||||
};
|
||||
|
||||
it('meldt een Local-regel met de url en bedient de map', async () => {
|
||||
const clientDir = siteDir();
|
||||
const run = start('--port', '0', '--strictPort', '--dir', clientDir);
|
||||
const line = await run.ready;
|
||||
const match = /Local:\s+http:\/\/127\.0\.0\.1:(\d+)\//.exec(line);
|
||||
expect(match).not.toBeNull();
|
||||
const answer = await ask(Number(match![1]), '/over-mij');
|
||||
expect(answer.status).toBe(200);
|
||||
});
|
||||
|
||||
it('stopt met exitcode 1 op een bezette poort met --strictPort', async () => {
|
||||
const blocker = createServer();
|
||||
await new Promise<void>((done) =>
|
||||
blocker.listen(0, '127.0.0.1', () => done()),
|
||||
);
|
||||
try {
|
||||
const taken = (blocker.address() as { port: number }).port;
|
||||
const run = start(
|
||||
`--port=${taken}`,
|
||||
'--strictPort',
|
||||
'--dir',
|
||||
siteDir(),
|
||||
);
|
||||
expect(await run.exited).toBe(1);
|
||||
expect(run.stderr()).toContain(String(taken));
|
||||
} finally {
|
||||
await new Promise((done) => blocker.close(done));
|
||||
}
|
||||
});
|
||||
|
||||
it('schuift naar een volgende poort zonder --strictPort', async () => {
|
||||
const blocker = createServer();
|
||||
await new Promise<void>((done) =>
|
||||
blocker.listen(0, '127.0.0.1', () => done()),
|
||||
);
|
||||
try {
|
||||
const taken = (blocker.address() as { port: number }).port;
|
||||
const run = start('--port', String(taken), '--dir', siteDir());
|
||||
const line = await run.ready;
|
||||
const port = Number(/:(\d+)\//.exec(line)![1]);
|
||||
expect(port).toBeGreaterThan(taken);
|
||||
} finally {
|
||||
await new Promise((done) => blocker.close(done));
|
||||
}
|
||||
});
|
||||
|
||||
it('stopt met exitcode 1 bij een ongeldige poort', async () => {
|
||||
const run = start('--port', 'abc');
|
||||
expect(await run.exited).toBe(1);
|
||||
expect(run.stderr()).toContain('Ongeldige poort');
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,233 @@
|
||||
// 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 { 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';
|
||||
|
||||
// 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),
|
||||
'Content-Length': statSync(target).size,
|
||||
};
|
||||
if (file.endsWith('.html')) headers['Cache-Control'] = 'no-cache';
|
||||
send(
|
||||
response,
|
||||
status,
|
||||
headers,
|
||||
request.method === 'HEAD' ? null : createReadStream(target),
|
||||
);
|
||||
};
|
||||
|
||||
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));
|
||||
}
|
||||
Reference in New Issue
Block a user