davaux 0.8.0

package/src/test/multipart.test.ts

@@ -0,0 +1,91 @@
+import assert from 'node:assert/strict'
+import { describe, test } from 'node:test'
+import { makeApp, request, route } from './helpers.js'
+
+function buildMultipart(
+  boundary: string,
+  parts: Array<{ name: string; value: string; filename?: string; mimetype?: string }>,
+): string {
+  let body = ''
+  for (const part of parts) {
+    body += `--${boundary}\r\n`
+    if (part.filename !== undefined) {
+      body += `Content-Disposition: form-data; name="${part.name}"; filename="${part.filename}"\r\n`
+      body += `Content-Type: ${part.mimetype ?? 'application/octet-stream'}\r\n`
+    } else {
+      body += `Content-Disposition: form-data; name="${part.name}"\r\n`
+    }
+    body += `\r\n${part.value}\r\n`
+  }
+  body += `--${boundary}--\r\n`
+  return body
+}
+
+describe('ctx.multipart()', () => {
+  const app = makeApp({ routes: [route('api/upload.post.ts', '/api/upload', 'post')] })
+  const boundary = 'TestBoundary123'
+  const ct = `multipart/form-data; boundary=${boundary}`
+
+  test('parses text fields', async () => {
+    const body = buildMultipart(boundary, [
+      { name: 'title', value: 'Hello World' },
+      { name: 'body', value: 'Some content here' },
+    ])
+    const { status, body: res } = await request(app, {
+      method: 'POST',
+      url: '/api/upload',
+      headers: { 'content-type': ct },
+      body,
+    })
+    assert.equal(status, 200)
+    const data = JSON.parse(res)
+    assert.equal(data.fields.title, 'Hello World')
+    assert.equal(data.fields.body, 'Some content here')
+  })
+
+  test('parses file uploads', async () => {
+    const body = buildMultipart(boundary, [
+      { name: 'avatar', value: 'fake-png-bytes', filename: 'photo.png', mimetype: 'image/png' },
+    ])
+    const { status, body: res } = await request(app, {
+      method: 'POST',
+      url: '/api/upload',
+      headers: { 'content-type': ct },
+      body,
+    })
+    assert.equal(status, 200)
+    const data = JSON.parse(res)
+    assert.equal(data.files.avatar.filename, 'photo.png')
+    assert.equal(data.files.avatar.mimetype, 'image/png')
+    assert.equal(data.files.avatar.size, Buffer.from('fake-png-bytes').length)
+  })
+
+  test('parses mixed fields and files', async () => {
+    const body = buildMultipart(boundary, [
+      { name: 'title', value: 'My Post' },
+      { name: 'image', value: 'imgdata', filename: 'hero.jpg', mimetype: 'image/jpeg' },
+    ])
+    const { status, body: res } = await request(app, {
+      method: 'POST',
+      url: '/api/upload',
+      headers: { 'content-type': ct },
+      body,
+    })
+    assert.equal(status, 200)
+    const data = JSON.parse(res)
+    assert.equal(data.fields.title, 'My Post')
+    assert.equal(data.files.image.filename, 'hero.jpg')
+    assert.equal(data.files.image.mimetype, 'image/jpeg')
+  })
+
+  test('missing Content-Type boundary returns 500', async () => {
+    const body = buildMultipart(boundary, [{ name: 'x', value: 'y' }])
+    const { status } = await request(app, {
+      method: 'POST',
+      url: '/api/upload',
+      headers: { 'content-type': 'multipart/form-data' },
+      body,
+    })
+    assert.equal(status, 500)
+  })
+})

package/src/test/oml-routing.test.ts

@@ -0,0 +1,59 @@
+import assert from 'node:assert/strict'
+import { describe, it } from 'node:test'
+import { makeApp, request, route } from './helpers.js'
+
+describe('OML page routing', () => {
+  it('renders an OML page handler to HTML', async () => {
+    const app = makeApp({ routes: [route('oml.page.ts', '/')] })
+    const { status, body } = await request(app, { url: '/' })
+    assert.equal(status, 200)
+    assert.ok(body.includes('<div class="oml-page">Hello, World!</div>'))
+  })
+
+  it('OML page reads query params at render time', async () => {
+    const app = makeApp({ routes: [route('oml.page.ts', '/')] })
+    const { body } = await request(app, { url: '/?name=Davaux' })
+    assert.ok(body.includes('Hello, Davaux!'))
+  })
+
+  it('OML page result is cached in production (isDev=false)', async () => {
+    const app = makeApp({ routes: [route('oml.page.ts', '/')] }, undefined, { include: ['/'] })
+    await request(app, { url: '/' })
+    assert.equal(app.omlCache.size, 1)
+  })
+
+  it('OML page is not cached in dev mode', async () => {
+    const { buildApp, dispatch } = await import('../router/handler.js')
+    const { makeScan, mockReq, mockRes } = await import('./helpers.js')
+    const app = buildApp(makeScan({ routes: [route('oml.page.ts', '/')] }), true)
+    const req = mockReq({ url: '/' })
+    const { res } = mockRes()
+    await dispatch(req, res, app)
+    assert.equal(app.omlCache.size, 0)
+  })
+
+  it('second request returns cached HTML without re-rendering', async () => {
+    const app = makeApp({ routes: [route('oml.page.ts', '/')] }, undefined, { include: ['/'] })
+    const first = await request(app, { url: '/' })
+    assert.equal(app.omlCache.size, 1)
+    const second = await request(app, { url: '/' })
+    assert.equal(second.body, first.body)
+    assert.equal(app.omlCache.size, 1)
+  })
+
+  it('cache entry stores both the OmlNode and pre-rendered HTML', async () => {
+    const app = makeApp({ routes: [route('oml.page.ts', '/')] }, undefined, { include: ['/'] })
+    await request(app, { url: '/' })
+    const [entry] = app.omlCache.values()
+    assert.ok(entry.node !== undefined)
+    assert.equal(typeof entry.html, 'string')
+    assert.ok(entry.html.includes('Hello, World!'))
+  })
+
+  it('different query strings produce separate cache entries', async () => {
+    const app = makeApp({ routes: [route('oml.page.ts', '/')] }, undefined, { include: ['/'] })
+    await request(app, { url: '/?name=Alice' })
+    await request(app, { url: '/?name=Bob' })
+    assert.equal(app.omlCache.size, 2)
+  })
+})

package/src/test/oml.test.ts

@@ -0,0 +1,429 @@
+import assert from 'node:assert/strict'
+import { describe, it } from 'node:test'
+import { clearAllFragments, defineFragment } from '../oml/fragment.js'
+import { blueprintToFile, renderToJsx } from '../oml/jsx.js'
+import { Fragment, jsx } from '../oml/jsx-runtime.js'
+import { renderToHtml } from '../oml/render.js'
+import type { OmlNode } from '../oml/types.js'
+import { parseOml, parseOmlBlueprint } from '../oml/types.js'
+
+// ─── jsx factory ──────────────────────────────────────────────────────────────
+
+describe('OML jsx factory', () => {
+  it('produces an element node for HTML tags', async () => {
+    const node = await jsx('div', { class: 'foo' })
+    assert.deepEqual(node, {
+      type: 'element',
+      tag: 'div',
+      id: undefined,
+      props: { class: 'foo' },
+      children: [],
+    })
+  })
+
+  it('wraps text children as #text nodes', async () => {
+    const node = await jsx('p', { children: 'hello' })
+    assert.deepEqual(node, {
+      type: 'element',
+      tag: 'p',
+      id: undefined,
+      props: {},
+      children: [{ type: '#text', value: 'hello' }],
+    })
+  })
+
+  it('resolves nested element children', async () => {
+    const child = jsx('span', { children: 'world' })
+    const node = await jsx('div', { children: [child] })
+    assert.equal((node as { type: string }).type, 'element')
+    const el = node as { children: OmlNode[] }
+    assert.equal(el.children.length, 1)
+    assert.deepEqual(el.children[0], {
+      type: 'element',
+      tag: 'span',
+      id: undefined,
+      props: {},
+      children: [{ type: '#text', value: 'world' }],
+    })
+  })
+
+  it('produces a #fragment node for Fragment type', async () => {
+    const node = await jsx(Fragment, { children: ['a', 'b'] })
+    assert.deepEqual(node, {
+      type: '#fragment',
+      children: [
+        { type: '#text', value: 'a' },
+        { type: '#text', value: 'b' },
+      ],
+    })
+  })
+
+  it('produces a #component node for function components', async () => {
+    async function Card(props: { title?: unknown; [k: string]: unknown }) {
+      return jsx('div', { children: props.title as string })
+    }
+    const node = await jsx(Card, { title: 'Hello' })
+    assert.equal((node as { type: string }).type, '#component')
+    const comp = node as { name: string; props: Record<string, unknown>; output: OmlNode }
+    assert.equal(comp.name, 'Card')
+    assert.deepEqual(comp.props, { title: 'Hello' })
+    assert.deepEqual(comp.output, {
+      type: 'element',
+      tag: 'div',
+      id: undefined,
+      props: {},
+      children: [{ type: '#text', value: 'Hello' }],
+    })
+  })
+
+  it('assigns id from key prop', async () => {
+    const node = await jsx('li', {}, 'item-1')
+    assert.equal((node as { id: string }).id, 'item-1')
+  })
+
+  it('omits null and boolean children', async () => {
+    const node = await jsx('div', { children: [null, false, 'visible'] })
+    const el = node as { children: OmlNode[] }
+    assert.equal(el.children.length, 1)
+    assert.deepEqual(el.children[0], { type: '#text', value: 'visible' })
+  })
+})
+
+// ─── renderToHtml ─────────────────────────────────────────────────────────────
+
+describe('OML renderToHtml', () => {
+  it('renders a simple element', () => {
+    const node: OmlNode = {
+      type: 'element',
+      tag: 'div',
+      props: { class: 'box' },
+      children: [{ type: '#text', value: 'hi' }],
+    }
+    assert.equal(renderToHtml(node), '<div class="box">hi</div>')
+  })
+
+  it('renders void elements without closing tag', () => {
+    const node: OmlNode = { type: 'element', tag: 'br', props: {}, children: [] }
+    assert.equal(renderToHtml(node), '<br>')
+  })
+
+  it('escapes text content', () => {
+    const node: OmlNode = { type: '#text', value: '<script>alert("xss")</script>' }
+    assert.equal(renderToHtml(node), '&lt;script&gt;alert(&quot;xss&quot;)&lt;/script&gt;')
+  })
+
+  it('renders null as empty string', () => {
+    assert.equal(renderToHtml(null), '')
+  })
+
+  it('renders #fragment by joining children', () => {
+    const node: OmlNode = {
+      type: '#fragment',
+      children: [
+        { type: '#text', value: 'a' },
+        { type: '#text', value: 'b' },
+      ],
+    }
+    assert.equal(renderToHtml(node), 'ab')
+  })
+
+  it('renders #component by delegating to its output node', () => {
+    const node: OmlNode = {
+      type: '#component',
+      name: 'Badge',
+      props: {},
+      output: { type: 'element', tag: 'span', props: { class: 'badge' }, children: [] },
+    }
+    assert.equal(renderToHtml(node), '<span class="badge"></span>')
+  })
+
+  it('handles dangerouslySetInnerHTML', () => {
+    const node: OmlNode = {
+      type: 'element',
+      tag: 'div',
+      props: { dangerouslySetInnerHTML: { __html: '<b>raw</b>' } },
+      children: [],
+    }
+    assert.equal(renderToHtml(node), '<div><b>raw</b></div>')
+  })
+
+  it('maps className to class attribute', async () => {
+    const node = await jsx('div', { className: 'foo' })
+    assert.equal(renderToHtml(node), '<div class="foo"></div>')
+  })
+
+  it('skips event handler props', async () => {
+    const node = await jsx('button', { onClick: () => {} })
+    assert.equal(renderToHtml(node), '<button></button>')
+  })
+})
+
+// ─── round-trip ───────────────────────────────────────────────────────────────
+
+describe('OML round-trip: jsx → renderToHtml', () => {
+  it('matches equivalent HTML', async () => {
+    const node = await jsx('section', {
+      class: 'card',
+      children: [jsx('h1', { children: 'Title' }), jsx('p', { children: 'Body text' })],
+    })
+    assert.equal(
+      renderToHtml(node),
+      '<section class="card"><h1>Title</h1><p>Body text</p></section>',
+    )
+  })
+})
+
+// ─── parseOml ─────────────────────────────────────────────────────────────────
+
+describe('parseOml', () => {
+  it('parses a valid element node from JSON', () => {
+    const json = JSON.parse(
+      JSON.stringify({
+        type: 'element',
+        tag: 'div',
+        props: { class: 'x' },
+        children: [],
+      }),
+    )
+    const node = parseOml(json)
+    assert.equal((node as { type: string }).type, 'element')
+  })
+
+  it('parses null as null', () => {
+    assert.equal(parseOml(null), null)
+  })
+
+  it('throws on unknown node type', () => {
+    assert.throws(() => parseOml({ type: 'unknown' }), /unknown node type/)
+  })
+
+  it('throws on non-object input', () => {
+    assert.throws(() => parseOml('bad'), /expected node object/)
+  })
+})
+
+describe('parseOmlBlueprint', () => {
+  it('parses a valid blueprint', () => {
+    const json = JSON.parse(
+      JSON.stringify({
+        id: 'bp:button',
+        name: 'Button',
+        props: { label: { type: 'string', required: true } },
+        output: { type: 'element', tag: 'button', props: {}, children: [] },
+      }),
+    )
+    const bp = parseOmlBlueprint(json)
+    assert.equal(bp.id, 'bp:button')
+    assert.equal(bp.name, 'Button')
+  })
+
+  it('throws if id is missing', () => {
+    assert.throws(() => parseOmlBlueprint({ name: 'X', output: null }), /missing id/)
+  })
+
+  it('preserves imports field', () => {
+    const bp = parseOmlBlueprint({
+      id: 'bp:card',
+      name: 'Card',
+      props: {},
+      output: null,
+      imports: { Badge: './Badge.js' },
+    })
+    assert.deepEqual(bp.imports, { Badge: './Badge.js' })
+  })
+})
+
+// ─── renderToJsx ──────────────────────────────────────────────────────────────
+
+describe('renderToJsx', () => {
+  it('renders a simple element', () => {
+    const node: OmlNode = {
+      type: 'element',
+      tag: 'div',
+      props: { className: 'box' },
+      children: [{ type: '#text', value: 'Hello' }],
+    }
+    assert.equal(renderToJsx(node), '<div className="box">Hello</div>')
+  })
+
+  it('renders a void element as self-closing', () => {
+    const node: OmlNode = { type: 'element', tag: 'br', props: {}, children: [] }
+    assert.equal(renderToJsx(node), '<br />')
+  })
+
+  it('renders nested elements with indentation', () => {
+    const node: OmlNode = {
+      type: 'element',
+      tag: 'ul',
+      props: {},
+      children: [
+        { type: 'element', tag: 'li', props: {}, children: [{ type: '#text', value: 'a' }] },
+        { type: 'element', tag: 'li', props: {}, children: [{ type: '#text', value: 'b' }] },
+      ],
+    }
+    assert.equal(renderToJsx(node), '<ul>\n  <li>a</li>\n  <li>b</li>\n</ul>')
+  })
+
+  it('renders a #fragment', () => {
+    const node: OmlNode = {
+      type: '#fragment',
+      children: [
+        { type: '#text', value: 'a' },
+        { type: '#text', value: 'b' },
+      ],
+    }
+    assert.equal(renderToJsx(node), '<>\n  a\n  b\n</>')
+  })
+
+  it('renders a #component as an invocation, not its output', () => {
+    const node: OmlNode = {
+      type: '#component',
+      name: 'Badge',
+      props: { count: 5 },
+      output: { type: 'element', tag: 'span', props: {}, children: [] },
+    }
+    assert.equal(renderToJsx(node), '<Badge count={5} />')
+  })
+
+  it('renders null as empty string', () => {
+    assert.equal(renderToJsx(null), '')
+  })
+
+  it('renders boolean props correctly', () => {
+    const node: OmlNode = {
+      type: 'element',
+      tag: 'input',
+      props: { disabled: true, required: false },
+      children: [],
+    }
+    assert.equal(renderToJsx(node), '<input disabled required={false} />')
+  })
+})
+
+// ─── blueprintToFile ──────────────────────────────────────────────────────────
+
+describe('blueprintToFile', () => {
+  it('generates a component file with no props', () => {
+    const output = blueprintToFile({
+      id: 'bp:divider',
+      name: 'Divider',
+      props: {},
+      output: { type: 'element', tag: 'hr', props: {}, children: [] },
+    })
+    assert.ok(output.includes('export default function Divider()'))
+    assert.ok(output.includes('<hr />'))
+  })
+
+  it('generates typed props in the function signature', () => {
+    const output = blueprintToFile({
+      id: 'bp:button',
+      name: 'Button',
+      props: {
+        label: { type: 'string', required: true },
+        disabled: { type: 'boolean', required: false },
+      },
+      output: { type: 'element', tag: 'button', props: {}, children: [] },
+    })
+    assert.ok(output.includes('label: string'))
+    assert.ok(output.includes('disabled?: boolean'))
+  })
+
+  it('generates import statements from blueprint.imports', () => {
+    const output = blueprintToFile({
+      id: 'bp:card',
+      name: 'Card',
+      props: {},
+      output: {
+        type: '#component',
+        name: 'Badge',
+        props: {},
+        output: null,
+      },
+      imports: { Badge: './Badge.js' },
+    })
+    assert.ok(output.includes("import Badge from './Badge.js'"))
+    assert.ok(output.includes('<Badge />'))
+  })
+})
+
+// ─── defineFragment ───────────────────────────────────────────────────────────
+
+describe('defineFragment', () => {
+  it('returns the correct node on first call', async () => {
+    const Nav = defineFragment(async () => jsx('nav', { children: 'Home' }))
+    const node = await Nav()
+    assert.equal(renderToHtml(node), '<nav>Home</nav>')
+  })
+
+  it('calls fn only once — second call returns cached node', async () => {
+    let calls = 0
+    const Widget = defineFragment(async () => {
+      calls++
+      return jsx('span', { children: 'hi' })
+    })
+    await Widget()
+    await Widget()
+    assert.equal(calls, 1)
+  })
+
+  it('caches per unique props using JSON.stringify by default', async () => {
+    let calls = 0
+    const Badge = defineFragment(async (props: { count: number }) => {
+      calls++
+      return jsx('span', { children: String(props.count) })
+    })
+    await Badge({ count: 1 })
+    await Badge({ count: 2 })
+    await Badge({ count: 1 })
+    assert.equal(calls, 2)
+  })
+
+  it('uses a custom key function when provided', async () => {
+    let calls = 0
+    const Item = defineFragment(
+      async (props: { id: string; ts: number }) => {
+        calls++
+        return jsx('li', { children: props.id })
+      },
+      { key: (p) => p.id },
+    )
+    await Item({ id: 'a', ts: 1 })
+    await Item({ id: 'a', ts: 999 }) // different ts, same key → cache hit
+    assert.equal(calls, 1)
+  })
+
+  it('re-runs fn after TTL expires', async () => {
+    let calls = 0
+    const Stale = defineFragment(
+      async () => {
+        calls++
+        return jsx('div', {})
+      },
+      { ttl: 1 },
+    )
+    await Stale()
+    await new Promise((r) => setTimeout(r, 5))
+    await Stale()
+    assert.equal(calls, 2)
+  })
+
+  it('clearAllFragments invalidates all fragment caches', async () => {
+    let aCalls = 0
+    let bCalls = 0
+    const A = defineFragment(async () => {
+      aCalls++
+      return jsx('div', {})
+    })
+    const B = defineFragment(async () => {
+      bCalls++
+      return jsx('span', {})
+    })
+    await A()
+    await B()
+    clearAllFragments()
+    await A()
+    await B()
+    assert.equal(aCalls, 2)
+    assert.equal(bCalls, 2)
+  })
+})

package/src/test/redirects.test.ts

@@ -0,0 +1,32 @@
+import assert from 'node:assert/strict'
+import { describe, test } from 'node:test'
+import { fix, makeApp, request, route } from './helpers.js'
+
+describe('redirects', () => {
+  test('redirect() in a handler returns 302 with Location header', async () => {
+    const app = makeApp({ routes: [route('redirect.page.ts', '/')] })
+    const { status, headers } = await request(app, { url: '/' })
+    assert.equal(status, 302)
+    assert.equal(headers.location, '/about')
+  })
+
+  test('redirect() in app middleware returns 302', async () => {
+    const app = makeApp({ routes: [route('index.page.ts', '/')] }, fix('_redirect_mw.ts'))
+    const { status, headers } = await request(app, { url: '/' })
+    assert.equal(status, 302)
+    assert.equal(headers.location, '/login')
+  })
+
+  test('redirect() with custom status code is respected', async () => {
+    const app = makeApp({ routes: [route('index.page.ts', '/')] }, fix('_redirect301_mw.ts'))
+    const { status, headers } = await request(app, { url: '/' })
+    assert.equal(status, 301)
+    assert.equal(headers.location, '/new-home')
+  })
+
+  test('redirect does not render a body', async () => {
+    const app = makeApp({ routes: [route('redirect.page.ts', '/')] })
+    const { body } = await request(app, { url: '/' })
+    assert.equal(body, '')
+  })
+})