app

Local-first trade for farms and co-ops
git clone https://radroots.dev/git/app.git
Log | Files | Refs | README | LICENSE

static.ts (4748B)


      1 import { createServer } from 'node:http';
      2 import { once } from 'node:events';
      3 import { readFile, realpath, stat } from 'node:fs/promises';
      4 import path from 'node:path';
      5 import { fileURLToPath } from 'node:url';
      6 
      7 // HC_TEST_ONLY_STATIC_SERVER: target-neutral static host contract, not an app server.
      8 // Admission is URL syntax only; client route owners validate coordinates and authority.
      9 function isNavigationPath(pathname: string) {
     10   if (new TextEncoder().encode(pathname).length > 2048) return false;
     11   const segments = pathname.slice(1).split('/');
     12   if (segments.some((segment) => !/^[A-Za-z0-9_-]+$/.test(segment)))
     13     return pathname === '/';
     14   const publicShells = new Set([
     15     'search',
     16     'sell',
     17     'selling',
     18     'messages',
     19     'about',
     20     'privacy'
     21   ]);
     22   return (
     23     (segments.length === 1 && publicShells.has(segments[0])) ||
     24     (segments[0] === 'products' &&
     25       (segments.length === 2 ||
     26         (segments.length === 3 && segments[2] === 'edit'))) ||
     27     (segments[0] === 'selling' &&
     28       segments[1] === 'drafts' &&
     29       segments.length === 3) ||
     30     (segments[0] === 'messages' && segments.length === 2)
     31   );
     32 }
     33 
     34 function acceptsHtml(accept: string) {
     35   return accept.split(',').some((entry) => {
     36     const [type, ...parameters] = entry.trim().split(';');
     37     if (type?.trim().toLowerCase() !== 'text/html') return false;
     38     const quality = parameters.find((parameter) =>
     39       parameter.trim().startsWith('q=')
     40     );
     41     return !quality || Number(quality.trim().slice(2)) > 0;
     42   });
     43 }
     44 
     45 export async function createStaticHarness(
     46   options: {
     47     buildRoot?: string;
     48     headers?: Readonly<Record<string, string>>;
     49   } = {}
     50 ) {
     51   const root = await realpath(
     52     options.buildRoot ??
     53       fileURLToPath(new URL('../../../build/', import.meta.url))
     54   );
     55   const headers = { ...options.headers };
     56   const server = createServer((request, response) => {
     57     for (const [name, value] of Object.entries(headers))
     58       response.setHeader(name, value);
     59     void (async () => {
     60       if (request.method !== 'GET') {
     61         response.writeHead(405).end();
     62         return;
     63       }
     64       // Validate before URL parsing can normalize literal or encoded dot segments.
     65       const raw = (request.url ?? '/').split('?')[0];
     66       if (!raw.startsWith('/') || /%2f|%5c|%25/i.test(raw)) {
     67         response.writeHead(404).end();
     68         return;
     69       }
     70       const requested = decodeURIComponent(raw);
     71       if (
     72         /[\\#]/u.test(requested) ||
     73         [...requested].some(
     74           (character) =>
     75             character.charCodeAt(0) < 32 || character.charCodeAt(0) === 127
     76         ) ||
     77         requested
     78           .split('/')
     79           .some((segment) => segment === '.' || segment === '..')
     80       ) {
     81         response.writeHead(404).end();
     82         return;
     83       }
     84       async function existing(relative: string) {
     85         try {
     86           const candidate = await realpath(path.resolve(root, '.' + relative));
     87           if (
     88             !candidate.startsWith(root + path.sep) ||
     89             !(await stat(candidate)).isFile()
     90           )
     91             return null;
     92           return candidate;
     93         } catch {
     94           return null;
     95         }
     96       }
     97       let file = await existing(requested === '/' ? '/index.html' : requested);
     98       const navigation = isNavigationPath(requested);
     99       if (!file && navigation) {
    100         file =
    101           (await existing(requested + '.html')) ??
    102           (await existing(requested + '/index.html'));
    103       }
    104       if (
    105         !file &&
    106         navigation &&
    107         acceptsHtml(request.headers.accept ?? '') &&
    108         (!request.headers['sec-fetch-dest'] ||
    109           request.headers['sec-fetch-dest'] === 'document')
    110       ) {
    111         file = await existing('/200.html');
    112       }
    113       if (!file) {
    114         response.writeHead(404).end();
    115         return;
    116       }
    117       const types: Record<string, string> = {
    118         '.html': 'text/html',
    119         '.js': 'text/javascript',
    120         '.css': 'text/css',
    121         '.json': 'application/json'
    122       };
    123       response.writeHead(200, {
    124         'content-type': types[path.extname(file)] ?? 'application/octet-stream'
    125       });
    126       response.end(await readFile(file));
    127     })().catch(() => response.writeHead(404).end());
    128   });
    129   server.listen(0, '127.0.0.1');
    130   await once(server, 'listening');
    131   const address = server.address();
    132   if (!address || typeof address === 'string')
    133     throw new Error('Missing loopback port');
    134   return {
    135     url: `http://127.0.0.1:${address.port}`,
    136     state: () => ({ listening: server.listening, childProcesses: 0 }),
    137     async close() {
    138       server.closeAllConnections();
    139       await new Promise<void>((resolve, reject) =>
    140         server.close((error) => (error ? reject(error) : resolve()))
    141       );
    142     }
    143   };
    144 }