davaux 0.8.0

package/src/test/body-limits.test.ts

@@ -0,0 +1,83 @@
+import assert from 'node:assert/strict'
+import { describe, test } from 'node:test'
+import { makeApp, request, route } from './helpers.js'
+
+describe('ctx.send()', () => {
+  test('responds with custom content-type and body', async () => {
+    const app = makeApp({ routes: [route('api/xml.get.ts', '/api/xml', 'get')] })
+    const { status, body, headers } = await request(app, { url: '/api/xml' })
+    assert.equal(status, 200)
+    assert.equal(body, '<root><item>hello</item></root>')
+    assert.equal(headers['content-type'], 'application/xml; charset=utf-8')
+  })
+
+  test('ctx.send() with custom status code', async () => {
+    const app = makeApp({ routes: [route('api/xml.get.ts', '/api/xml', 'get')] })
+    const { status } = await request(app, { url: '/api/xml' })
+    assert.equal(status, 200)
+  })
+})
+
+describe('ctx.formAll()', () => {
+  const app = makeApp({ routes: [route('api/form-all.post.ts', '/form-all', 'post')] })
+
+  test('single-value fields are wrapped in arrays', async () => {
+    const { status, body } = await request(app, {
+      method: 'POST',
+      url: '/form-all',
+      body: 'title=Hello&author=Alice',
+    })
+    assert.equal(status, 200)
+    const data = JSON.parse(body)
+    assert.deepEqual(data.title, ['Hello'])
+    assert.deepEqual(data.author, ['Alice'])
+  })
+
+  test('multi-value fields collect all values', async () => {
+    const { status, body } = await request(app, {
+      method: 'POST',
+      url: '/form-all',
+      body: 'tag=tech&tag=news&tag=coding',
+    })
+    assert.equal(status, 200)
+    const data = JSON.parse(body)
+    assert.deepEqual(data.tag, ['tech', 'news', 'coding'])
+  })
+
+  test('mixed single and multi-value fields', async () => {
+    const { status, body } = await request(app, {
+      method: 'POST',
+      url: '/form-all',
+      body: 'title=Post&tag=a&tag=b',
+    })
+    assert.equal(status, 200)
+    const data = JSON.parse(body)
+    assert.deepEqual(data.title, ['Post'])
+    assert.deepEqual(data.tag, ['a', 'b'])
+  })
+})
+
+describe('body size limits', () => {
+  test('form body within limit succeeds', async () => {
+    const app = makeApp({ routes: [route('api/form-limited.post.ts', '/upload', 'post')] })
+    const { status, body } = await request(app, {
+      method: 'POST',
+      url: '/upload',
+      body: 'name=Alice',
+    })
+    assert.equal(status, 200)
+    const data = JSON.parse(body) as { ok: boolean; keys: number }
+    assert.equal(data.ok, true)
+    assert.equal(data.keys, 1)
+  })
+
+  test('form body exceeding limit returns 413', async () => {
+    const app = makeApp({ routes: [route('api/form-limited.post.ts', '/upload', 'post')] })
+    const { status } = await request(app, {
+      method: 'POST',
+      url: '/upload',
+      body: `name=${'x'.repeat(100)}`, // 105 bytes > 50 byte limit
+    })
+    assert.equal(status, 413)
+  })
+})

package/src/test/errors.test.ts

@@ -0,0 +1,53 @@
+import assert from 'node:assert/strict'
+import { describe, test } from 'node:test'
+import { fix, layout, makeApp, request, route } from './helpers.js'
+
+const errorPage = fix('_error.ts')
+
+describe('error pages', () => {
+  test('unmatched route returns 404 plain text when no error page is configured', async () => {
+    const app = makeApp({ routes: [] })
+    const { status, body } = await request(app, { url: '/missing' })
+    assert.equal(status, 404)
+    assert.ok(body.includes('Not Found'))
+  })
+
+  test('unmatched route renders custom error page with status 404', async () => {
+    const app = makeApp({ routes: [], errorPage })
+    const { status, body } = await request(app, { url: '/missing' })
+    assert.equal(status, 404)
+    const result = JSON.parse(body) as Record<string, unknown>
+    assert.equal(result.status, 404)
+  })
+
+  test('handler that throws renders custom error page with status 500', async () => {
+    const app = makeApp({
+      routes: [route('throw.page.ts', '/')],
+      errorPage,
+    })
+    const { status, body } = await request(app, { url: '/' })
+    assert.equal(status, 500)
+    const result = JSON.parse(body) as Record<string, unknown>
+    assert.equal(result.status, 500)
+    assert.ok(typeof result.message === 'string')
+  })
+
+  test('error page inherits layout when one is configured', async () => {
+    const app = makeApp({
+      routes: [],
+      layouts: [layout('_layout.ts')],
+      errorPage,
+    })
+    const { status, body } = await request(app, { url: '/missing' })
+    assert.equal(status, 404)
+    // The layout wraps the error page output
+    assert.ok(body.includes('<html>'))
+  })
+
+  test('error page receives ctx.state populated by app middleware', async () => {
+    const app = makeApp({ routes: [], errorPage }, fix('_global.ts'))
+    const { body } = await request(app, { url: '/missing' })
+    const result = JSON.parse(body) as Record<string, unknown>
+    assert.deepEqual(result.order, ['global'])
+  })
+})

package/src/test/fixtures/routes/[id].page.ts

@@ -0,0 +1,3 @@
+import { definePage, type ExtractParams } from '../../../index.js'
+
+export default definePage<ExtractParams<'[id]'>>((ctx) => `<h1>Item: ${ctx.params.id}</h1>`)

package/src/test/fixtures/routes/_error.ts

@@ -0,0 +1,6 @@
+import { defineError } from '../../../index.js'
+
+// Outputs status + message + ctx.state as JSON so tests can inspect all three.
+export default defineError(({ status, message, ctx }) =>
+  JSON.stringify({ status, message, ...ctx.state }),
+)

package/src/test/fixtures/routes/_global.ts

@@ -0,0 +1,8 @@
+import { defineMiddleware } from '../../../index.js'
+
+// Pushes 'global' onto ctx.state.order so middleware ordering can be verified.
+export default defineMiddleware(async (ctx, next) => {
+  if (!ctx.state.order) ctx.state.order = []
+  ;(ctx.state.order as string[]).push('global')
+  await next()
+})

package/src/test/fixtures/routes/_layout-template.ts

@@ -0,0 +1,7 @@
+import { defineLayout } from '../../../index.js'
+
+// Template literal layout using ${children} directly — no await needed.
+export default defineLayout(({ children, ctx }) => {
+  const title = ctx.head.title ?? 'Test'
+  return `<html><head><title>${title}</title></head><body>${children}</body></html>`
+})

package/src/test/fixtures/routes/_layout.ts

@@ -0,0 +1,7 @@
+import { defineLayout } from '../../../index.js'
+
+export default defineLayout(async ({ children, ctx }) => {
+  const title = ctx.head.title ?? 'Test'
+  const content = await children
+  return `<html><head><title>${title}</title></head><body>${content}</body></html>`
+})

package/src/test/fixtures/routes/_layout_scripts.ts

@@ -0,0 +1,8 @@
+import { defineLayout } from '../../../index.js'
+
+export default defineLayout(async ({ children, ctx }) => {
+  const content = await children
+  const scripts = ctx.head.scripts.map((s) => `<script src="${s}"></script>`).join('')
+  const styles = ctx.head.stylesheets.map((s) => `<link rel="stylesheet" href="${s}">`).join('')
+  return `<html><head>${styles}${scripts}</head><body>${content}</body></html>`
+})

package/src/test/fixtures/routes/_middleware.ts

@@ -0,0 +1,8 @@
+import { defineMiddleware } from '../../../index.js'
+
+// Pushes 'scoped' onto ctx.state.order so middleware ordering can be verified.
+export default defineMiddleware(async (ctx, next) => {
+  if (!ctx.state.order) ctx.state.order = []
+  ;(ctx.state.order as string[]).push('scoped')
+  await next()
+})

package/src/test/fixtures/routes/_redirect301_mw.ts

@@ -0,0 +1,5 @@
+import { defineMiddleware, redirect } from '../../../index.js'
+
+export default defineMiddleware(async (_ctx, _next) => {
+  redirect('/new-home', 301)
+})

package/src/test/fixtures/routes/_redirect_mw.ts

@@ -0,0 +1,5 @@
+import { defineMiddleware, redirect } from '../../../index.js'
+
+export default defineMiddleware(async (_ctx, _next) => {
+  redirect('/login')
+})

package/src/test/fixtures/routes/about.page.ts

@@ -0,0 +1,6 @@
+import { definePage } from '../../../index.js'
+
+export default definePage((ctx) => {
+  ctx.head.title = 'About'
+  return '<h1>About</h1>'
+})

package/src/test/fixtures/routes/action.page.ts

@@ -0,0 +1,11 @@
+import { defineAction, definePage } from '../../../index.js'
+
+export const action = defineAction(async (ctx) => {
+  const data = await ctx.form()
+  return { submitted: data.name ?? '(none)' }
+})
+
+export default definePage((ctx) => {
+  const result = ctx.state.actionResult as { submitted: string } | undefined
+  return result ? `submitted:${result.submitted}` : 'form'
+})

package/src/test/fixtures/routes/api/form-all.post.ts

@@ -0,0 +1,5 @@
+import { defineHandler } from '../../../../index.js'
+
+export default defineHandler(async (ctx) => {
+  return ctx.formAll()
+})

package/src/test/fixtures/routes/api/form-limited.post.ts

@@ -0,0 +1,6 @@
+import { defineHandler } from '../../../../index.js'
+
+export default defineHandler(async (ctx) => {
+  const data = await ctx.form(undefined, { maxBytes: 50 })
+  return { ok: true, keys: Object.keys(data).length }
+})

package/src/test/fixtures/routes/api/response-obj.get.ts

@@ -0,0 +1,17 @@
+import { defineHandler } from '../../../../index.js'
+
+export default defineHandler(async (ctx) => {
+  const shape = ctx.query.get('shape') ?? 'json'
+
+  if (shape === 'text') {
+    return new Response('hello plain', { status: 200, headers: { 'Content-Type': 'text/plain' } })
+  }
+  if (shape === 'created') {
+    return Response.json({ created: true }, { status: 201 })
+  }
+  if (shape === 'nocontent') {
+    return new Response(null, { status: 204 })
+  }
+
+  return Response.json({ ok: true })
+})

package/src/test/fixtures/routes/api/upload.post.ts

@@ -0,0 +1,14 @@
+import { defineHandler } from '../../../../index.js'
+
+export default defineHandler(async (ctx) => {
+  const result = await ctx.multipart()
+  return {
+    fields: result.fields,
+    files: Object.fromEntries(
+      Object.entries(result.files).map(([k, f]) => [
+        k,
+        { filename: f.filename, mimetype: f.mimetype, size: f.data.length },
+      ]),
+    ),
+  }
+})

package/src/test/fixtures/routes/api/users.get.ts

@@ -0,0 +1,3 @@
+import { defineHandler } from '../../../../index.js'
+
+export default defineHandler(() => [{ id: 1, name: 'Alice' }])

package/src/test/fixtures/routes/api/xml.get.ts

@@ -0,0 +1,5 @@
+import { defineHandler } from '../../../../index.js'
+
+export default defineHandler((ctx) => {
+  ctx.send('<root><item>hello</item></root>', 'application/xml; charset=utf-8')
+})

package/src/test/fixtures/routes/auth/_middleware.ts

@@ -0,0 +1,11 @@
+import { defineMiddleware } from '../../../../index.js'
+
+// Returns 401 when no ?token query param is present.
+export default defineMiddleware(async (ctx, next) => {
+  if (!ctx.query.get('token')) {
+    ctx.res.writeHead(401, { 'Content-Type': 'text/plain' })
+    ctx.res.end('Unauthorized')
+    return
+  }
+  await next()
+})

package/src/test/fixtures/routes/auth/protected.page.ts

@@ -0,0 +1,3 @@
+import { definePage } from '../../../../index.js'
+
+export default definePage(() => '<p>Protected content</p>')

package/src/test/fixtures/routes/index.page.ts

@@ -0,0 +1,3 @@
+import { definePage } from '../../../index.js'
+
+export default definePage(() => '<h1>Home</h1>')

package/src/test/fixtures/routes/oml.page.ts

@@ -0,0 +1,7 @@
+import { jsx } from '../../../oml/jsx-runtime.js'
+import { definePage } from '../../../types.js'
+
+export default definePage(async (ctx) => {
+  const name = ctx.query.get('name') ?? 'World'
+  return jsx('div', { class: 'oml-page', children: `Hello, ${name}!` })
+})

package/src/test/fixtures/routes/redirect.page.ts

@@ -0,0 +1,3 @@
+import { definePage, redirect } from '../../../index.js'
+
+export default definePage(() => redirect('/about'))

package/src/test/fixtures/routes/ssg/[slug].page.ts

@@ -0,0 +1,8 @@
+import { definePage, defineStaticPaths, type ExtractParams } from '../../../../index.js'
+
+export const getStaticPaths = defineStaticPaths(() => [
+  { params: { slug: 'hello' } },
+  { params: { slug: 'world' } },
+])
+
+export default definePage<ExtractParams<'ssg/[slug]'>>((ctx) => `<h1>${ctx.params.slug}</h1>`)

package/src/test/fixtures/routes/ssg/server.page.ts

@@ -0,0 +1,5 @@
+import { definePage } from '../../../../index.js'
+
+export const prerender = false
+
+export default definePage(() => '<h1>Server rendered</h1>')

package/src/test/fixtures/routes/state.page.ts

@@ -0,0 +1,4 @@
+import { definePage } from '../../../index.js'
+
+// Outputs ctx.state as JSON so tests can verify middleware side-effects.
+export default definePage((ctx) => JSON.stringify(ctx.state))

package/src/test/fixtures/routes/throw.page.ts

@@ -0,0 +1,5 @@
+import { definePage } from '../../../index.js'
+
+export default definePage(() => {
+  throw new Error('intentional test error')
+})

package/src/test/fixtures/routes/wiki/[...slug].page.ts

@@ -0,0 +1,3 @@
+import { definePage } from '../../../../index.js'
+
+export default definePage((ctx) => `<h1>Wiki: ${ctx.params.slug}</h1>`)

package/src/test/helpers.ts

@@ -0,0 +1,132 @@
+import type { IncomingMessage, ServerResponse } from 'node:http'
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import type { OmlCacheConfig } from '../config.js'
+import type { CompiledApp } from '../router/handler.js'
+import { buildApp, dispatch } from '../router/handler.js'
+import type { LayoutFile, MiddlewareFile, RouteFile, RouteType, ScanResult } from '../types.js'
+
+const FIXTURES = fileURLToPath(new URL('./fixtures/routes', import.meta.url))
+
+/** Resolve a path relative to the fixtures/routes directory. */
+export function fix(...parts: string[]): string {
+  return join(FIXTURES, ...parts)
+}
+
+/** Build a RouteFile pointing to a fixture, deriving params from the URL pattern. */
+export function route(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(file), urlPattern, type, params }
+}
+
+/** Build a LayoutFile pointing to a fixture. */
+export function layout(file: string): LayoutFile {
+  const filePath = fix(file)
+  return { filePath, dirPath: dirname(filePath) }
+}
+
+/** Build a MiddlewareFile pointing to a fixture. */
+export function middleware(file: string): MiddlewareFile {
+  const filePath = fix(file)
+  return { filePath, dirPath: dirname(filePath) }
+}
+
+/** Construct a minimal ScanResult, defaulting all collections to empty. */
+export function makeScan(opts: Partial<ScanResult> = {}): ScanResult {
+  return {
+    routes: [],
+    layouts: [],
+    middlewares: [],
+    errorPage: undefined,
+    ...opts,
+  }
+}
+
+/** Build a CompiledApp from a partial ScanResult and an optional app middleware path. */
+export function makeApp(
+  scan: Partial<ScanResult> = {},
+  appMiddlewarePath?: string,
+  omlCacheConfig?: OmlCacheConfig,
+): CompiledApp {
+  return buildApp(makeScan(scan), false, [], [], appMiddlewarePath, '', false, omlCacheConfig)
+}
+
+// ─── Mock request ─────────────────────────────────────────────────────────────
+
+export function mockReq(options: {
+  method?: string
+  url: string
+  headers?: Record<string, string>
+  body?: string
+}): IncomingMessage {
+  const { method = 'GET', url, headers = {}, body = '' } = options
+  return {
+    method,
+    url,
+    headers: { host: 'localhost', ...headers },
+    on(event: string, listener: (...args: unknown[]) => void) {
+      if (event === 'data' && body) setImmediate(() => listener(Buffer.from(body)))
+      if (event === 'end') setImmediate(() => listener())
+      return this
+    },
+    removeListener() {
+      return this
+    },
+    destroy() {
+      return this
+    },
+  } as unknown as IncomingMessage
+}
+
+// ─── Mock response ────────────────────────────────────────────────────────────
+
+export function mockRes() {
+  let status = 200
+  let body = ''
+  let sent = false
+  let ended = false
+  const hdrs: Record<string, string | string[]> = {}
+
+  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
+      if (h) for (const [k, v] of Object.entries(h)) hdrs[k.toLowerCase()] = v
+    },
+    end(data?: string | Buffer) {
+      if (data != null) body = typeof data === 'string' ? data : data.toString('utf-8')
+      ended = true
+    },
+    getHeader: (name: string) => hdrs[name.toLowerCase()],
+    setHeader(name: string, value: string | string[]) {
+      hdrs[name.toLowerCase()] = value
+    },
+  } as unknown as ServerResponse
+
+  return { res, result: () => ({ status, body, headers: hdrs }) }
+}
+
+// ─── Convenience dispatch helper ──────────────────────────────────────────────
+
+/** Run a request through an app and return the captured response. */
+export async function request(app: CompiledApp, options: Parameters<typeof mockReq>[0]) {
+  const req = mockReq(options)
+  const { res, result } = mockRes()
+  await dispatch(req, res, app)
+  return result()
+}

package/src/test/layouts.test.ts

@@ -0,0 +1,76 @@
+import assert from 'node:assert/strict'
+import { describe, test } from 'node:test'
+import { layout, makeApp, request, route } from './helpers.js'
+
+describe('layouts', () => {
+  test('layout wraps page content with outer HTML shell', async () => {
+    const app = makeApp({
+      routes: [route('index.page.ts', '/')],
+      layouts: [layout('_layout.ts')],
+    })
+    const { status, body } = await request(app, { url: '/' })
+    assert.equal(status, 200)
+    assert.ok(body.includes('<html>'))
+    assert.ok(body.includes('</html>'))
+    assert.ok(body.includes('Home'))
+  })
+
+  test('page content appears inside layout body', async () => {
+    const app = makeApp({
+      routes: [route('about.page.ts', '/about')],
+      layouts: [layout('_layout.ts')],
+    })
+    const { body } = await request(app, { url: '/about' })
+    // The layout fixture wraps with <body>...</body>
+    assert.ok(body.includes('<body>'))
+    assert.ok(body.includes('<h1>About</h1>'))
+    assert.ok(body.includes('</body>'))
+  })
+
+  test('ctx.head properties set by page are readable in layout', async () => {
+    const app = makeApp({
+      routes: [route('about.page.ts', '/about')],
+      layouts: [layout('_layout.ts')],
+    })
+    const { body } = await request(app, { url: '/about' })
+    // The layout fixture renders ctx.head.title in <title>
+    assert.ok(body.includes('<title>About</title>'))
+  })
+
+  test('layout does not apply to routes outside its directory', async () => {
+    // layout('_layout.ts') covers the root fixtures dir
+    // If we only register it for /auth, it should not wrap the root route
+    // We test the inverse: root layout covers all descendant routes
+    const app = makeApp({
+      routes: [route('auth/protected.page.ts', '/auth/protected')],
+      layouts: [layout('_layout.ts')],
+    })
+    const { body } = await request(app, { url: '/auth/protected?token=x' })
+    // The root layout covers /auth/protected because it's a descendant
+    assert.ok(body.includes('<html>'))
+    assert.ok(body.includes('Protected'))
+  })
+
+  test('template literal layout renders children without await', async () => {
+    const app = makeApp({
+      routes: [route('about.page.ts', '/about')],
+      layouts: [layout('_layout-template.ts')],
+    })
+    const { status, body } = await request(app, { url: '/about' })
+    assert.equal(status, 200)
+    // Children must be injected as raw HTML, not "[object Promise]"
+    assert.ok(body.includes('<h1>About</h1>'), 'page content rendered')
+    assert.ok(!body.includes('[object'), 'no Promise leak into output')
+    assert.ok(body.includes('<title>About</title>'), 'ctx.head.title readable')
+  })
+
+  test('response includes DOCTYPE when layout provides full HTML', async () => {
+    const app = makeApp({
+      routes: [route('index.page.ts', '/')],
+      layouts: [layout('_layout.ts')],
+    })
+    const { body } = await request(app, { url: '/' })
+    // sendPage prepends DOCTYPE if not present; the layout starts with <html>
+    assert.ok(body.startsWith('<!DOCTYPE html>') || body.includes('<html>'))
+  })
+})

package/src/test/middleware.test.ts

@@ -0,0 +1,69 @@
+import assert from 'node:assert/strict'
+import { describe, test } from 'node:test'
+import { fix, makeApp, middleware, request, route } from './helpers.js'
+
+describe('middleware', () => {
+  test('scoped middleware runs before the route handler', async () => {
+    const app = makeApp({
+      routes: [route('state.page.ts', '/')],
+      middlewares: [middleware('_middleware.ts')],
+    })
+    const { body } = await request(app, { url: '/' })
+    const state = JSON.parse(body) as Record<string, unknown>
+    assert.deepEqual(state.order, ['scoped'])
+  })
+
+  test('scoped middleware does not run for routes in other directories', async () => {
+    // auth/_middleware.ts only covers auth/*, not root routes
+    const app = makeApp({
+      routes: [route('state.page.ts', '/'), route('auth/protected.page.ts', '/auth/protected')],
+      middlewares: [middleware('auth/_middleware.ts')],
+    })
+    // Root route should not be intercepted by the auth middleware
+    const { status } = await request(app, { url: '/' })
+    assert.equal(status, 200)
+  })
+
+  test('scoped middleware gates access to routes it covers', async () => {
+    const app = makeApp({
+      routes: [route('auth/protected.page.ts', '/auth/protected')],
+      middlewares: [middleware('auth/_middleware.ts')],
+    })
+    // Without token → 401
+    const denied = await request(app, { url: '/auth/protected' })
+    assert.equal(denied.status, 401)
+
+    // With token → 200
+    const allowed = await request(app, { url: '/auth/protected?token=secret' })
+    assert.equal(allowed.status, 200)
+    assert.ok(allowed.body.includes('Protected'))
+  })
+
+  test('app middleware runs on matched routes', async () => {
+    const app = makeApp({ routes: [route('state.page.ts', '/')] }, fix('_global.ts'))
+    const { body } = await request(app, { url: '/' })
+    const state = JSON.parse(body) as Record<string, unknown>
+    assert.deepEqual(state.order, ['global'])
+  })
+
+  test('app middleware runs on 404 responses', async () => {
+    const app = makeApp({ routes: [], errorPage: fix('_error.ts') }, fix('_global.ts'))
+    const { body } = await request(app, { url: '/missing' })
+    const result = JSON.parse(body) as Record<string, unknown>
+    assert.equal(result.status, 404)
+    assert.deepEqual(result.order, ['global'])
+  })
+
+  test('app middleware runs before scoped middleware', async () => {
+    const app = makeApp(
+      {
+        routes: [route('state.page.ts', '/')],
+        middlewares: [middleware('_middleware.ts')],
+      },
+      fix('_global.ts'),
+    )
+    const { body } = await request(app, { url: '/' })
+    const state = JSON.parse(body) as Record<string, unknown>
+    assert.deepEqual(state.order, ['global', 'scoped'])
+  })
+})