@pyreon/server 0.15.0 → 0.16.0

package/src/tests/server.test.ts

@@ -1,5 +1,6 @@
 import type { ComponentFn, VNode } from '@pyreon/core'
 import { h } from '@pyreon/core'
+import { RouterView } from '@pyreon/router'
 import { createHandler } from '../handler'
 import {
   buildClientEntryTag,
@@ -225,6 +226,82 @@ describe('createHandler', () => {
   })
 })
 
+// ─── M1.2 — runtime SSR 404 layout chrome ─────────────────────────────────────
+//
+// PR L5 added `findNotFoundFallback` to the router's `resolveRoute` so an
+// unmatched URL produces a synthetic chain `[...ancestorLayouts, syntheticLeaf]`
+// with `isNotFound: true`. M1.2 wires the handler to read that flag and emit
+// HTTP 404 instead of 200 — while still serving the layout-wrapped 404 HTML.
+//
+// Without M1.2, the synthetic chain still rendered (so the HTML body was
+// correct under L5) but the response status stayed at 200 — broken contract
+// for static-host CDNs, search engines, and curl-driven monitoring.
+//
+// Bisect: remove the `resolved?.isNotFound === true ? 404 : 200` ternary in
+// `handler.ts` (replace with `200`) → both specs below fail with
+// `expected 200 to be 404`.
+
+describe('createHandler — M1.2 runtime SSR 404 layout chrome', () => {
+  const HomePage: ComponentFn = () => h('h1', { 'data-testid': 'home' }, 'Home')
+  const NotFound: ComponentFn = () => h('h1', { 'data-testid': 'not-found' }, 'Page Not Found')
+  const Layout: ComponentFn = () =>
+    h(
+      'div',
+      { 'data-testid': 'layout' },
+      h('nav', { 'data-testid': 'nav' }, 'NAV'),
+      h(RouterView, {}),
+    )
+
+  // Routes tree shape mirrors fs-router's `_404.tsx` convention:
+  //   - parent layout has `notFoundComponent` attached
+  //   - matched children render normally
+  const routes = [
+    {
+      path: '/',
+      component: Layout,
+      notFoundComponent: NotFound,
+      children: [{ path: '/', component: HomePage }],
+    },
+  ]
+
+  test('matched URL renders normally with status 200', async () => {
+    const handler = createHandler({ App: RouterView, routes })
+    const res = await handler(new Request('http://localhost/'))
+    expect(res.status).toBe(200)
+    const html = await res.text()
+    expect(html).toContain('data-testid="home"')
+    expect(html).toContain('data-testid="layout"') // chrome wraps page
+  })
+
+  test('unmatched URL emits HTTP 404 with layout chrome + not-found body', async () => {
+    const handler = createHandler({ App: RouterView, routes })
+    const res = await handler(new Request('http://localhost/this-page-does-not-exist'))
+
+    // M1.2 — status 404 sourced from router.currentRoute().isNotFound.
+    expect(res.status).toBe(404)
+
+    const html = await res.text()
+    // The 404 component renders.
+    expect(html).toContain('data-testid="not-found"')
+    expect(html).toContain('Page Not Found')
+    // PR L5 — the parent layout wraps the 404 (the win that started with L5,
+    // M1.2 just adds the HTTP status).
+    expect(html).toContain('data-testid="layout"')
+    expect(html).toContain('data-testid="nav"')
+  })
+
+  test('legacy routes tree without notFoundComponent emits 200 (no synthetic chain)', async () => {
+    // Backward-compat: apps without `_404.tsx` in the routes tree fall through
+    // to whatever the App renders (typically empty RouterView). The handler
+    // doesn't synthesize a 404 status out of thin air — it requires the
+    // router's `findNotFoundFallback` to produce the synthetic chain first.
+    const plainRoutes = [{ path: '/specific', component: HomePage }]
+    const handler = createHandler({ App: RouterView, routes: plainRoutes })
+    const res = await handler(new Request('http://localhost/unrelated'))
+    expect(res.status).toBe(200)
+  })
+})
+
 // ─── Stream mode ──────────────────────────────────────────────────────────────
 
 describe('createHandler — stream mode', () => {
@@ -382,6 +459,27 @@ describe('middleware types', () => {
     // Just verify the module can be imported — it's pure types
     expect(mod).toBeDefined()
   })
+
+  test('useRequestLocals returns the current request locals from context', async () => {
+    const { useRequestLocals } = await import('../middleware')
+    // Outside a request context, returns the default empty object — exercises
+    // the function-call path so coverage sees it (was 50%/never-called before).
+    const locals = useRequestLocals()
+    expect(typeof locals).toBe('object')
+    expect(locals).not.toBeNull()
+  })
+
+  test('createHandler invokes collectStyles and prepends styleTag to head', async () => {
+    const App: ComponentFn = () => h('div', null, 'styled')
+    const handler = createHandler({
+      App,
+      routes: [{ path: '/', component: App }],
+      collectStyles: () => '<style data-test="style">.x{color:red}</style>',
+    })
+    const res = await handler(new Request('http://localhost/'))
+    const html = await res.text()
+    expect(html).toContain('<style data-test="style">')
+  })
 })
 
 // ─── Islands ─────────────────────────────────────────────────────────────────
@@ -462,7 +560,12 @@ describe('island', () => {
 
   test('island() resolves direct function module (not { default })', async () => {
     const Inner: ComponentFn = () => h('span', null, 'direct')
-    const Widget = island(() => Promise.resolve({ default: Inner }), { name: 'Direct' })
+    // Loader returns the ComponentFn DIRECTLY (no { default } wrapper) —
+    // covers the function-typeof branch in the unwrap code.
+    const Widget = island(
+      () => Promise.resolve(Inner as unknown as ComponentFn),
+      { name: 'Direct' },
+    )
 
     const vnode = await (Widget as unknown as (props: Record<string, unknown>) => Promise<VNode>)(
       {},
@@ -488,6 +591,63 @@ describe('island', () => {
     expect(meta.hydrate).toBe('visible')
   })
 
+  test("island() defaults prefetch to 'none' and does NOT emit data-prefetch attribute", async () => {
+    const Inner: ComponentFn = () => h('div', null)
+    const Widget = island(() => Promise.resolve({ default: Inner }), {
+      name: 'NoPrefetch',
+      hydrate: 'visible',
+    })
+    expect((Widget as unknown as { prefetch: string }).prefetch).toBe('none')
+    const vnode = await (Widget as unknown as (props: Record<string, unknown>) => Promise<VNode>)(
+      {},
+    )
+    expect('data-prefetch' in vnode.props).toBe(false)
+  })
+
+  test("island() emits data-prefetch when paired with a deferred hydrate strategy", async () => {
+    const Inner: ComponentFn = () => h('div', null)
+    const Widget = island(() => Promise.resolve({ default: Inner }), {
+      name: 'PrefetchIdle',
+      hydrate: 'visible',
+      prefetch: 'idle',
+    })
+    expect((Widget as unknown as { prefetch: string }).prefetch).toBe('idle')
+    const vnode = await (Widget as unknown as (props: Record<string, unknown>) => Promise<VNode>)(
+      {},
+    )
+    expect(vnode.props['data-prefetch']).toBe('idle')
+    expect(vnode.props['data-hydrate']).toBe('visible')
+  })
+
+  test("island() suppresses data-prefetch when hydrate='load' (loader runs synchronously)", async () => {
+    const Inner: ComponentFn = () => h('div', null)
+    const Widget = island(() => Promise.resolve({ default: Inner }), {
+      name: 'PointlessPrefetch',
+      hydrate: 'load',
+      prefetch: 'idle',
+    })
+    const vnode = await (Widget as unknown as (props: Record<string, unknown>) => Promise<VNode>)(
+      {},
+    )
+    // Metadata still records what the user asked for, but the runtime
+    // attribute is suppressed because prefetch is meaningless on load.
+    expect((Widget as unknown as { prefetch: string }).prefetch).toBe('idle')
+    expect('data-prefetch' in vnode.props).toBe(false)
+  })
+
+  test("island() suppresses data-prefetch when hydrate='never' (defeats zero-JS strategy)", async () => {
+    const Inner: ComponentFn = () => h('div', null)
+    const Widget = island(() => Promise.resolve({ default: Inner }), {
+      name: 'NeverPrefetch',
+      hydrate: 'never',
+      prefetch: 'visible',
+    })
+    const vnode = await (Widget as unknown as (props: Record<string, unknown>) => Promise<VNode>)(
+      {},
+    )
+    expect('data-prefetch' in vnode.props).toBe(false)
+  })
+
   test('island() serializes empty props as empty object', async () => {
     const Inner: ComponentFn = () => h('div', null)
     const Widget = island(() => Promise.resolve({ default: Inner }), { name: 'Empty' })
@@ -497,6 +657,65 @@ describe('island', () => {
     )
     expect(vnode.props['data-props']).toBe('{}')
   })
+
+  test('island() falls back to {} on BigInt props instead of throwing the SSR', async () => {
+    const Inner: ComponentFn = () => h('div', null)
+    const Widget = island(() => Promise.resolve({ default: Inner }), { name: 'BigIntProps' })
+
+    const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
+    const vnode = await (Widget as unknown as (props: Record<string, unknown>) => Promise<VNode>)({
+      // BigInt is not JSON-serializable; would throw inside JSON.stringify pre-fix
+      huge: BigInt('9007199254740993'),
+    })
+    expect(vnode.props['data-props']).toBe('{}')
+    expect(errorSpy).toHaveBeenCalledWith(
+      expect.stringContaining('BigInt or circular reference'),
+    )
+    errorSpy.mockRestore()
+  })
+
+  test('island() falls back to {} on circular-reference props', async () => {
+    const Inner: ComponentFn = () => h('div', null)
+    const Widget = island(() => Promise.resolve({ default: Inner }), { name: 'CircularProps' })
+
+    const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
+    const cyclic: Record<string, unknown> = { name: 'foo' }
+    cyclic.self = cyclic
+    const vnode = await (Widget as unknown as (props: Record<string, unknown>) => Promise<VNode>)({
+      data: cyclic,
+    })
+    expect(vnode.props['data-props']).toBe('{}')
+    expect(errorSpy).toHaveBeenCalled()
+    errorSpy.mockRestore()
+  })
+
+  test('island() warns when children prop is dropped (dev only)', async () => {
+    const Inner: ComponentFn = () => h('div', null)
+    const Widget = island(() => Promise.resolve({ default: Inner }), { name: 'WithKids' })
+
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+    await (Widget as unknown as (props: Record<string, unknown>) => Promise<VNode>)({
+      title: 'has children',
+      children: h('span', null, 'kid'),
+    })
+    expect(warnSpy).toHaveBeenCalledWith(
+      expect.stringContaining('island "WithKids" was passed children'),
+    )
+    warnSpy.mockRestore()
+  })
+
+  test('island() does NOT warn when children is undefined (no real children)', async () => {
+    const Inner: ComponentFn = () => h('div', null)
+    const Widget = island(() => Promise.resolve({ default: Inner }), { name: 'NoKidsWarn' })
+
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+    await (Widget as unknown as (props: Record<string, unknown>) => Promise<VNode>)({
+      title: 'no children',
+      children: undefined,
+    })
+    expect(warnSpy).not.toHaveBeenCalled()
+    warnSpy.mockRestore()
+  })
 })
 
 // ─── SSG ─────────────────────────────────────────────────────────────────────