@davaux/multisite 0.8.0

package/src/test/multisite.test.ts

@@ -0,0 +1,650 @@
+import assert from 'node:assert/strict'
+import { once } from 'node:events'
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs'
+import type { IncomingMessage, ServerResponse } from 'node:http'
+import http from 'node:http'
+import { tmpdir } from 'node:os'
+import { dirname, join } from 'node:path'
+import { after, before, describe, test } from 'node:test'
+import { fileURLToPath } from 'node:url'
+import type { RouteFile, RouteType, ScanResult } from 'davaux'
+import {
+  buildMultisiteApps,
+  defineSites,
+  dispatchToSite,
+  mergeScanResults,
+  startMultisiteServer,
+} from '../index.js'
+
+const FIXTURES = fileURLToPath(new URL('./fixtures', import.meta.url))
+const baseDir = join(FIXTURES, 'base/routes')
+const siteADir = join(FIXTURES, 'site-a/routes')
+const siteBDir = join(FIXTURES, 'site-b/routes')
+
+// ─── Test helpers ─────────────────────────────────────────────────────────────
+
+function fix(base: string, ...parts: string[]): string {
+  return join(base, ...parts)
+}
+
+function makeRoute(
+  dir: string,
+  file: string,
+  urlPattern: string,
+  type: RouteType = 'page',
+): RouteFile {
+  const params = [
+    ...[...urlPattern.matchAll(/:(\w+)/g)].map((m) => m[1]),
+    ...[...urlPattern.matchAll(/\*(\w+)/g)].map((m) => m[1]),
+  ]
+  return { filePath: fix(dir, file), urlPattern, type, params }
+}
+
+function makeLayout(dir: string, file: string) {
+  const filePath = fix(dir, file)
+  return { filePath, dirPath: dirname(filePath) }
+}
+
+function makeMiddleware(dir: string, file: string) {
+  const filePath = fix(dir, file)
+  return { filePath, dirPath: dirname(filePath) }
+}
+
+function emptyScan(): ScanResult {
+  return { routes: [], layouts: [], middlewares: [] }
+}
+
+function mockReq(options: { url: string; host: string; method?: string }): IncomingMessage {
+  const { url, host, method = 'GET' } = options
+  return {
+    method,
+    url,
+    headers: { host },
+    on(event: string, listener: (...args: unknown[]) => void) {
+      if (event === 'end') setImmediate(() => listener())
+      return this
+    },
+    removeListener() {
+      return this
+    },
+    destroy() {
+      return this
+    },
+  } as unknown as IncomingMessage
+}
+
+function mockRes() {
+  let status = 200
+  let body = ''
+  let sent = false
+  let ended = false
+
+  const res = {
+    get statusCode() {
+      return status
+    },
+    set statusCode(v: number) {
+      status = v
+    },
+    get headersSent() {
+      return sent
+    },
+    get writableEnded() {
+      return ended
+    },
+    writeHead(code: number, _h?: Record<string, string>) {
+      status = code
+      sent = true
+    },
+    end(data?: string | Buffer) {
+      if (data != null) body = typeof data === 'string' ? data : data.toString('utf-8')
+      ended = true
+    },
+    getHeader: () => undefined,
+    setHeader() {},
+  } as unknown as ServerResponse
+
+  return { res, result: () => ({ status, body }) }
+}
+
+async function siteRequest(
+  sites: Awaited<ReturnType<typeof buildMultisiteApps>>,
+  options: { url: string; host: string; method?: string },
+) {
+  const req = mockReq(options)
+  const { res, result } = mockRes()
+  await dispatchToSite(sites, req, res)
+  return result()
+}
+
+function httpGet(
+  port: number,
+  path: string,
+  host: string,
+): Promise<{ status: number; body: string; type: string }> {
+  return new Promise((resolve, reject) => {
+    http
+      .get({ hostname: '127.0.0.1', port, path, headers: { host } }, (res) => {
+        const chunks: Buffer[] = []
+        res.on('data', (c: Buffer) => chunks.push(c))
+        res.on('end', () =>
+          resolve({
+            status: res.statusCode ?? 0,
+            body: Buffer.concat(chunks).toString(),
+            type: String(res.headers['content-type'] ?? ''),
+          }),
+        )
+      })
+      .on('error', reject)
+  })
+}
+
+// ─── defineSites ──────────────────────────────────────────────────────────────
+
+describe('defineSites', () => {
+  test('returns the config object unchanged (identity)', () => {
+    const config = {
+      baseDir: '/some/path',
+      sites: [{ name: 'a', hostname: 'a.com' }],
+    }
+    assert.equal(defineSites(config), config)
+  })
+})
+
+// ─── mergeScanResults — unit tests ────────────────────────────────────────────
+
+describe('mergeScanResults', () => {
+  test('overlay route overrides base route at same URL pattern and type', () => {
+    const baseIndex = makeRoute(baseDir, 'index.page.ts', '/')
+    const overlayIndex = makeRoute(siteADir, 'index.page.ts', '/')
+    const merged = mergeScanResults(
+      { ...emptyScan(), routes: [baseIndex] },
+      { ...emptyScan(), routes: [overlayIndex] },
+    )
+    assert.equal(merged.routes.length, 1)
+    assert.equal(merged.routes[0].filePath, overlayIndex.filePath)
+  })
+
+  test('base routes not in overlay are preserved', () => {
+    const baseAbout = makeRoute(baseDir, 'about.page.ts', '/about')
+    const overlayIndex = makeRoute(siteADir, 'index.page.ts', '/')
+    const merged = mergeScanResults(
+      { ...emptyScan(), routes: [baseAbout] },
+      { ...emptyScan(), routes: [overlayIndex] },
+    )
+    assert.equal(merged.routes.length, 2)
+    const patterns = merged.routes.map((r) => r.urlPattern)
+    assert.ok(patterns.includes('/about'))
+    assert.ok(patterns.includes('/'))
+  })
+
+  test('overlay-only routes are included alongside base routes', () => {
+    const baseIndex = makeRoute(baseDir, 'index.page.ts', '/')
+    const overlayShop = makeRoute(siteADir, 'shop.page.ts', '/shop')
+    const merged = mergeScanResults(
+      { ...emptyScan(), routes: [baseIndex] },
+      { ...emptyScan(), routes: [overlayShop] },
+    )
+    assert.equal(merged.routes.length, 2)
+  })
+
+  test('merged routes are sorted static before dynamic', () => {
+    const dynamicBase = makeRoute(baseDir, 'about.page.ts', '/:slug')
+    const staticOverlay = makeRoute(siteADir, 'index.page.ts', '/about')
+    const merged = mergeScanResults(
+      { ...emptyScan(), routes: [dynamicBase] },
+      { ...emptyScan(), routes: [staticOverlay] },
+    )
+    assert.equal(merged.routes[0].urlPattern, '/about')
+    assert.equal(merged.routes[1].urlPattern, '/:slug')
+  })
+
+  test('wildcard routes sort after dynamic routes', () => {
+    const dynamic = makeRoute(baseDir, 'slug.page.ts', '/:slug')
+    const wildcard = makeRoute(baseDir, 'catch.page.ts', '/*all')
+    const merged = mergeScanResults({ ...emptyScan(), routes: [wildcard, dynamic] }, emptyScan())
+    assert.equal(merged.routes[0].urlPattern, '/:slug')
+    assert.equal(merged.routes[1].urlPattern, '/*all')
+  })
+
+  test('routes with different types at the same URL pattern are both kept', () => {
+    const baseGet = makeRoute(baseDir, 'api.get.ts', '/api', 'get')
+    const overlayPost = makeRoute(siteADir, 'api.post.ts', '/api', 'post')
+    const merged = mergeScanResults(
+      { ...emptyScan(), routes: [baseGet] },
+      { ...emptyScan(), routes: [overlayPost] },
+    )
+    assert.equal(merged.routes.length, 2)
+    const types = merged.routes.map((r) => r.type)
+    assert.ok(types.includes('get'))
+    assert.ok(types.includes('post'))
+  })
+
+  test('overlay layout at same dirPath replaces base layout', () => {
+    const baseLayout = makeLayout(baseDir, '_layout.ts')
+    const overlayLayout = makeLayout(siteADir, '_layout.ts')
+    // Give them the same dirPath to simulate same-depth override
+    const syntheticOverlay = { filePath: overlayLayout.filePath, dirPath: baseLayout.dirPath }
+    const merged = mergeScanResults(
+      { ...emptyScan(), layouts: [baseLayout] },
+      { ...emptyScan(), layouts: [syntheticOverlay] },
+    )
+    assert.equal(merged.layouts.length, 1)
+    assert.equal(merged.layouts[0].filePath, overlayLayout.filePath)
+  })
+
+  test('layouts at different dirPaths are both kept', () => {
+    const baseLayout = makeLayout(baseDir, '_layout.ts')
+    const overlayLayout = makeLayout(siteADir, '_layout.ts')
+    // Different dirPaths — both survive
+    const merged = mergeScanResults(
+      { ...emptyScan(), layouts: [baseLayout] },
+      { ...emptyScan(), layouts: [overlayLayout] },
+    )
+    assert.equal(merged.layouts.length, 2)
+  })
+
+  test('overlay middleware at same dirPath replaces base middleware', () => {
+    const baseMw = makeMiddleware(baseDir, '_middleware.ts')
+    const overlayMw = makeMiddleware(siteADir, '_middleware.ts')
+    const syntheticOverlay = { filePath: overlayMw.filePath, dirPath: baseMw.dirPath }
+    const merged = mergeScanResults(
+      { ...emptyScan(), middlewares: [baseMw] },
+      { ...emptyScan(), middlewares: [syntheticOverlay] },
+    )
+    assert.equal(merged.middlewares.length, 1)
+    assert.equal(merged.middlewares[0].filePath, overlayMw.filePath)
+  })
+
+  test('base middlewares at non-overlapping dirs are all preserved', () => {
+    const baseMw = makeMiddleware(baseDir, '_middleware.ts')
+    const baseSubMw = makeMiddleware(join(baseDir, 'admin'), '_middleware.ts')
+    const overlayMw = makeMiddleware(siteADir, '_middleware.ts')
+    // overlayMw.dirPath !== baseMw.dirPath && != baseSubMw.dirPath — all three survive
+    const merged = mergeScanResults(
+      { ...emptyScan(), middlewares: [baseMw, baseSubMw] },
+      { ...emptyScan(), middlewares: [overlayMw] },
+    )
+    assert.equal(merged.middlewares.length, 3)
+  })
+
+  test('overlay error page wins over base error page', () => {
+    const merged = mergeScanResults(
+      { ...emptyScan(), errorPage: fix(baseDir, '_error.ts') },
+      { ...emptyScan(), errorPage: fix(siteBDir, '_error.ts') },
+    )
+    assert.equal(merged.errorPage, fix(siteBDir, '_error.ts'))
+  })
+
+  test('base error page used when overlay has none', () => {
+    const merged = mergeScanResults(
+      { ...emptyScan(), errorPage: fix(baseDir, '_error.ts') },
+      emptyScan(),
+    )
+    assert.equal(merged.errorPage, fix(baseDir, '_error.ts'))
+  })
+})
+
+// ─── buildMultisiteApps + dispatchToSite — integration tests ─────────────────
+
+describe('buildMultisiteApps', () => {
+  test('base route is served when site has no override', async () => {
+    const sites = await buildMultisiteApps(
+      defineSites({
+        baseDir,
+        sites: [{ name: 'site-a', hostname: 'site-a.com', routesDir: siteADir }],
+      }),
+    )
+    // /about exists only in base; site-a does not override it
+    const { status, body } = await siteRequest(sites, { url: '/about', host: 'site-a.com' })
+    assert.equal(status, 200)
+    assert.ok(body.includes('About (base)'))
+  })
+
+  test('site route overrides base route at same URL', async () => {
+    const sites = await buildMultisiteApps(
+      defineSites({
+        baseDir,
+        sites: [{ name: 'site-a', hostname: 'site-a.com', routesDir: siteADir }],
+      }),
+    )
+    const { status, body } = await siteRequest(sites, { url: '/', host: 'site-a.com' })
+    assert.equal(status, 200)
+    assert.ok(body.includes('Home (site-a)'))
+    assert.ok(!body.includes('Home (base)'))
+  })
+
+  test('site-unique route is served', async () => {
+    const sites = await buildMultisiteApps(
+      defineSites({
+        baseDir,
+        sites: [{ name: 'site-a', hostname: 'site-a.com', routesDir: siteADir }],
+      }),
+    )
+    const { status, body } = await siteRequest(sites, { url: '/shop', host: 'site-a.com' })
+    assert.equal(status, 200)
+    assert.ok(body.includes('Shop (site-a)'))
+  })
+
+  test('site-b gets its own override of /about', async () => {
+    const sites = await buildMultisiteApps(
+      defineSites({
+        baseDir,
+        sites: [
+          { name: 'site-a', hostname: 'site-a.com', routesDir: siteADir },
+          { name: 'site-b', hostname: 'site-b.com', routesDir: siteBDir },
+        ],
+      }),
+    )
+    const a = await siteRequest(sites, { url: '/about', host: 'site-a.com' })
+    const b = await siteRequest(sites, { url: '/about', host: 'site-b.com' })
+    assert.ok(a.body.includes('About (base)'))
+    assert.ok(b.body.includes('About (site-b)'))
+  })
+
+  test('hostname dispatch routes to the correct site', async () => {
+    const sites = await buildMultisiteApps(
+      defineSites({
+        baseDir,
+        sites: [
+          { name: 'site-a', hostname: 'site-a.com', routesDir: siteADir },
+          { name: 'site-b', hostname: 'site-b.com', routesDir: siteBDir },
+        ],
+      }),
+    )
+    const a = await siteRequest(sites, { url: '/', host: 'site-a.com' })
+    const b = await siteRequest(sites, { url: '/', host: 'site-b.com' })
+    assert.ok(a.body.includes('Home (site-a)'))
+    assert.ok(b.body.includes('Home (base)')) // site-b has no index override
+  })
+
+  test('wildcard fallback site handles unknown hosts', async () => {
+    const sites = await buildMultisiteApps(
+      defineSites({
+        baseDir,
+        sites: [{ name: 'default', hostname: '*', routesDir: siteADir }],
+      }),
+    )
+    const { status, body } = await siteRequest(sites, { url: '/', host: 'unknown.com' })
+    assert.equal(status, 200)
+    assert.ok(body.includes('Home (site-a)'))
+  })
+
+  test('dispatchToSite returns false for unregistered host with no wildcard', async () => {
+    const sites = await buildMultisiteApps(
+      defineSites({
+        baseDir,
+        sites: [{ name: 'site-a', hostname: 'site-a.com', routesDir: siteADir }],
+      }),
+    )
+    const req = mockReq({ url: '/', host: 'other.com' })
+    const { res } = mockRes()
+    const handled = await dispatchToSite(sites, req, res)
+    assert.equal(handled, false)
+  })
+
+  test('dispatchToSite returns true when a site handles the request', async () => {
+    const sites = await buildMultisiteApps(
+      defineSites({
+        baseDir,
+        sites: [{ name: 'site-a', hostname: 'site-a.com', routesDir: siteADir }],
+      }),
+    )
+    const req = mockReq({ url: '/', host: 'site-a.com' })
+    const { res } = mockRes()
+    const handled = await dispatchToSite(sites, req, res)
+    assert.equal(handled, true)
+  })
+
+  test('site config is accessible via getSite in a route handler', async () => {
+    const sites = await buildMultisiteApps(
+      defineSites<{ name: string }>({
+        sites: [
+          {
+            name: 'site-a',
+            hostname: 'site-a.com',
+            routesDir: siteADir,
+            config: { name: 'My Site A' },
+          },
+        ],
+      }),
+    )
+    const { status, body } = await siteRequest(sites, { url: '/config', host: 'site-a.com' })
+    assert.equal(status, 200)
+    assert.ok(body.includes('site-config:My Site A'))
+  })
+
+  test('getSite returns undefined when site has no config', async () => {
+    const sites = await buildMultisiteApps(
+      defineSites({
+        sites: [{ name: 'site-a', hostname: 'site-a.com', routesDir: siteADir }],
+      }),
+    )
+    const { body } = await siteRequest(sites, { url: '/config', host: 'site-a.com' })
+    assert.ok(body.includes('site-config:none'))
+  })
+
+  test('site with no routesDir serves only base routes', async () => {
+    const sites = await buildMultisiteApps(
+      defineSites({
+        baseDir,
+        sites: [{ name: 'docs', hostname: 'docs.com' }],
+      }),
+    )
+    const { status, body } = await siteRequest(sites, { url: '/about', host: 'docs.com' })
+    assert.equal(status, 200)
+    assert.ok(body.includes('About (base)'))
+  })
+
+  test('site with no baseDir serves only its own routes', async () => {
+    const sites = await buildMultisiteApps(
+      defineSites({
+        sites: [{ name: 'site-a', hostname: 'site-a.com', routesDir: siteADir }],
+      }),
+    )
+    // /about is only in base — 404 when no baseDir
+    const notFound = await siteRequest(sites, { url: '/about', host: 'site-a.com' })
+    assert.equal(notFound.status, 404)
+    // /shop is site-a-only — should work
+    const found = await siteRequest(sites, { url: '/shop', host: 'site-a.com' })
+    assert.ok(found.body.includes('Shop (site-a)'))
+  })
+
+  test('site-b custom error page is used for 404s on site-b', async () => {
+    const sites = await buildMultisiteApps(
+      defineSites({
+        baseDir,
+        sites: [{ name: 'site-b', hostname: 'site-b.com', routesDir: siteBDir }],
+      }),
+    )
+    const { status, body } = await siteRequest(sites, { url: '/nonexistent', host: 'site-b.com' })
+    assert.equal(status, 404)
+    assert.ok(body.includes('site-b error: 404'))
+  })
+
+  test('multiple hostnames on one site all resolve to the same app', async () => {
+    const sites = await buildMultisiteApps(
+      defineSites({
+        baseDir,
+        sites: [
+          {
+            name: 'site-a',
+            hostname: ['site-a.com', 'www.site-a.com'],
+            routesDir: siteADir,
+          },
+        ],
+      }),
+    )
+    const a1 = await siteRequest(sites, { url: '/', host: 'site-a.com' })
+    const a2 = await siteRequest(sites, { url: '/', host: 'www.site-a.com' })
+    assert.equal(a1.body, a2.body)
+    assert.ok(a1.body.includes('Home (site-a)'))
+  })
+
+  test('port in Host header is stripped for hostname matching', async () => {
+    const sites = await buildMultisiteApps(
+      defineSites({
+        baseDir,
+        sites: [{ name: 'site-a', hostname: 'site-a.com', routesDir: siteADir }],
+      }),
+    )
+    const { status, body } = await siteRequest(sites, { url: '/', host: 'site-a.com:3000' })
+    assert.equal(status, 200)
+    assert.ok(body.includes('Home (site-a)'))
+  })
+
+  test('site middleware runs and sets state for its routes', async () => {
+    const sites = await buildMultisiteApps(
+      defineSites({
+        baseDir,
+        sites: [{ name: 'site-a', hostname: 'site-a.com', routesDir: siteADir }],
+      }),
+    )
+    // site-a's _middleware.ts sets ctx.state.visited = 'site-a'
+    const { body } = await siteRequest(sites, { url: '/state', host: 'site-a.com' })
+    assert.ok(body.includes('state:site-a'))
+  })
+})
+
+// ─── startMultisiteServer — HTTP integration tests ────────────────────────────
+
+describe('startMultisiteServer', () => {
+  let server: ReturnType<typeof startMultisiteServer>
+  let serverPort: number
+  let tmpDir: string
+
+  before(async () => {
+    tmpDir = mkdtempSync(join(tmpdir(), 'davaux-ms-test-'))
+
+    // Pre-built assets for site-a (production mode picks these up automatically)
+    mkdirSync(join(tmpDir, '_davaux', 'site-a'), { recursive: true })
+    writeFileSync(join(tmpDir, '_davaux', 'site-a', 'islands.js'), '/* islands-a */')
+    writeFileSync(join(tmpDir, '_davaux', 'site-a', 'client.js'), '/* client-a */')
+    writeFileSync(join(tmpDir, '_davaux', 'styles.css'), '/* styles */')
+
+    // Shared public dir
+    const sharedPublic = join(tmpDir, 'public')
+    mkdirSync(sharedPublic)
+    writeFileSync(join(sharedPublic, 'shared.txt'), 'shared-content')
+    writeFileSync(join(sharedPublic, 'both.txt'), 'from-shared')
+
+    // Site-a per-site public dir
+    const siteAPublic = join(tmpDir, 'site-a-public')
+    mkdirSync(siteAPublic)
+    writeFileSync(join(siteAPublic, 'sitea.txt'), 'sitea-content')
+    writeFileSync(join(siteAPublic, 'both.txt'), 'from-sitea')
+
+    const apps = await buildMultisiteApps(
+      defineSites({
+        baseDir,
+        publicDir: sharedPublic,
+        sites: [
+          {
+            name: 'site-a',
+            hostname: 'site-a.com',
+            routesDir: siteADir,
+            publicDir: siteAPublic,
+          },
+          {
+            name: 'site-b',
+            hostname: 'site-b.com',
+            routesDir: siteBDir,
+            // no islands, no client, no per-site publicDir
+          },
+        ],
+      }),
+      { isDev: false, cwd: tmpDir },
+    )
+
+    server = startMultisiteServer(apps, { port: 0, hostname: '127.0.0.1' })
+    await once(server, 'listening')
+    serverPort = (server.address() as { port: number }).port
+  })
+
+  after(() => {
+    server?.close()
+    rmSync(tmpDir, { recursive: true, force: true })
+  })
+
+  test('unknown host with no wildcard returns 404', async () => {
+    const { status } = await httpGet(serverPort, '/', 'unknown.com')
+    assert.equal(status, 404)
+  })
+
+  test('/_davaux/livereload.js returns 200 with JS content-type', async () => {
+    const { status, type } = await httpGet(serverPort, '/_davaux/livereload.js', 'site-a.com')
+    assert.equal(status, 200)
+    assert.ok(type.includes('javascript'))
+  })
+
+  test('/_davaux/livereload-worker.js returns 200 with JS content-type', async () => {
+    const { status, type } = await httpGet(
+      serverPort,
+      '/_davaux/livereload-worker.js',
+      'site-a.com',
+    )
+    assert.equal(status, 200)
+    assert.ok(type.includes('javascript'))
+  })
+
+  test('/_davaux/islands.js served from islandsPath for site-a', async () => {
+    const { status, body } = await httpGet(serverPort, '/_davaux/islands.js', 'site-a.com')
+    assert.equal(status, 200)
+    assert.ok(body.includes('islands-a'))
+  })
+
+  test('/_davaux/islands.js returns 404 for site with no islands file', async () => {
+    const { status } = await httpGet(serverPort, '/_davaux/islands.js', 'site-b.com')
+    assert.equal(status, 404)
+  })
+
+  test('/_davaux/styles.css served from shared stylesPath', async () => {
+    const { status, body, type } = await httpGet(serverPort, '/_davaux/styles.css', 'site-a.com')
+    assert.equal(status, 200)
+    assert.ok(type.includes('css'))
+    assert.ok(body.includes('styles'))
+  })
+
+  test('/_davaux/client.js served from clientPath for site-a', async () => {
+    const { status, body } = await httpGet(serverPort, '/_davaux/client.js', 'site-a.com')
+    assert.equal(status, 200)
+    assert.ok(body.includes('client-a'))
+  })
+
+  test('/_davaux/client.js returns 404 for site with no client file', async () => {
+    const { status } = await httpGet(serverPort, '/_davaux/client.js', 'site-b.com')
+    assert.equal(status, 404)
+  })
+
+  test('static file served from shared publicDir', async () => {
+    const { status, body } = await httpGet(serverPort, '/shared.txt', 'site-b.com')
+    assert.equal(status, 200)
+    assert.equal(body, 'shared-content')
+  })
+
+  test('static file served from site-specific publicDir', async () => {
+    const { status, body } = await httpGet(serverPort, '/sitea.txt', 'site-a.com')
+    assert.equal(status, 200)
+    assert.equal(body, 'sitea-content')
+  })
+
+  test('per-site publicDir takes priority over shared publicDir', async () => {
+    const a = await httpGet(serverPort, '/both.txt', 'site-a.com')
+    const b = await httpGet(serverPort, '/both.txt', 'site-b.com')
+    assert.equal(a.body, 'from-sitea') // per-site file wins for site-a
+    assert.equal(b.body, 'from-shared') // shared file used for site-b
+  })
+
+  test('path traversal does not serve files outside publicDir', async () => {
+    const secret = join(tmpDir, 'secret.txt')
+    writeFileSync(secret, 'secret-data')
+    const { body } = await httpGet(serverPort, '/../secret.txt', 'site-a.com')
+    assert.ok(!body.includes('secret-data'))
+  })
+
+  test('routes are dispatched correctly through the server', async () => {
+    const { status, body } = await httpGet(serverPort, '/', 'site-a.com')
+    assert.equal(status, 200)
+    assert.ok(body.includes('Home (site-a)'))
+  })
+})

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "skipLibCheck": true,
+    "lib": ["ESNext"],
+    "types": ["node"]
+  },
+  "include": ["src/**/*"]
+}