@jasonshimmy/vite-plugin-cer-app 0.6.0 → 0.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jasonshimmy/vite-plugin-cer-app",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "Nuxt-style meta-framework for @jasonshimmy/custom-elements-runtime",
   "type": "module",
   "keywords": [
@@ -37,6 +37,10 @@
       "import": "./dist/types/index.js",
       "require": "./dist/types/index.cjs",
       "types": "./dist/types/index.d.ts"
+    },
+    "./isr": {
+      "import": "./dist/runtime/isr-handler.js",
+      "types": "./dist/runtime/isr-handler.d.ts"
     }
   },
   "bin": {

package/src/__tests__/cli/preview-isr.test.ts

@@ -3,6 +3,7 @@ import type { IncomingMessage, ServerResponse } from 'node:http'
 import {
   matchRoutePattern,
   findRevalidate,
+  findRenderMode,
   renderForIsr,
   serveFromIsrCache,
   type IsrCacheEntry,
@@ -119,6 +120,49 @@ describe('findRevalidate', () => {
   })
 })
 
+// ─── findRenderMode ───────────────────────────────────────────────────────────
+
+describe('findRenderMode', () => {
+  it('returns null for an empty routes array', () => {
+    expect(findRenderMode([], '/about')).toBeNull()
+  })
+
+  it('returns null when no route matches', () => {
+    const routes = [{ path: '/contact', meta: { render: 'server' } }]
+    expect(findRenderMode(routes, '/about')).toBeNull()
+  })
+
+  it('returns null when matched route has no render meta', () => {
+    const routes = [{ path: '/about' }]
+    expect(findRenderMode(routes, '/about')).toBeNull()
+  })
+
+  it('returns "server" for a matching route with render: server', () => {
+    const routes = [{ path: '/dashboard', meta: { render: 'server' } }]
+    expect(findRenderMode(routes, '/dashboard')).toBe('server')
+  })
+
+  it('returns "spa" for a matching route with render: spa', () => {
+    const routes = [{ path: '/profile', meta: { render: 'spa' } }]
+    expect(findRenderMode(routes, '/profile')).toBe('spa')
+  })
+
+  it('returns "static" for a matching route with render: static', () => {
+    const routes = [{ path: '/about', meta: { render: 'static' } }]
+    expect(findRenderMode(routes, '/about')).toBe('static')
+  })
+
+  it('returns null for unrecognised render values', () => {
+    const routes = [{ path: '/about', meta: { render: 'unknown' } }]
+    expect(findRenderMode(routes, '/about')).toBeNull()
+  })
+
+  it('matches dynamic routes', () => {
+    const routes = [{ path: '/blog/:slug', meta: { render: 'server' } }]
+    expect(findRenderMode(routes, '/blog/my-post')).toBe('server')
+  })
+})
+
 // ─── renderForIsr ─────────────────────────────────────────────────────────────
 
 describe('renderForIsr', () => {

package/src/__tests__/plugin/build-ssg.test.ts

@@ -4,6 +4,7 @@ vi.mock('node:fs', () => ({ existsSync: vi.fn().mockReturnValue(false) }))
 vi.mock('node:fs/promises', () => ({
   writeFile: vi.fn().mockResolvedValue(undefined),
   mkdir: vi.fn().mockResolvedValue(undefined),
+  readFile: vi.fn().mockResolvedValue(''),
 }))
 vi.mock('fast-glob', () => ({ default: vi.fn().mockResolvedValue([]) }))
 vi.mock('vite', () => ({
@@ -14,7 +15,7 @@ vi.mock('../../plugin/build-ssr.js', () => ({ buildSSR: vi.fn().mockResolvedValu
 vi.mock('../../plugin/path-utils.js', () => ({ buildRouteEntry: vi.fn() }))
 
 import { existsSync } from 'node:fs'
-import { writeFile, mkdir } from 'node:fs/promises'
+import { writeFile, mkdir, readFile } from 'node:fs/promises'
 import fg from 'fast-glob'
 import { createServer } from 'vite'
 import { buildSSR } from '../../plugin/build-ssr.js'
@@ -38,8 +39,10 @@ beforeEach(() => {
   vi.mocked(writeFile).mockClear()
   vi.mocked(mkdir).mockClear()
   vi.mocked(fg).mockClear()
+  vi.mocked(readFile).mockClear()
   vi.mocked(existsSync).mockReturnValue(false)
   vi.mocked(fg).mockResolvedValue([])
+  vi.mocked(readFile).mockResolvedValue('')
   vi.mocked(buildRouteEntry).mockReset()
 })
 
@@ -263,6 +266,128 @@ describe('buildSSG — path collection', () => {
   })
 })
 
+// ─── render: 'server' / 'spa' skip ───────────────────────────────────────────
+
+describe('buildSSG — render strategy skip (static pages)', () => {
+  it('skips static page with render: server', async () => {
+    vi.mocked(existsSync).mockReturnValue(true)
+    vi.mocked(fg).mockResolvedValue(['/project/app/pages/dashboard.ts'])
+    vi.mocked(readFile).mockResolvedValue("export const meta = { render: 'server' }")
+    vi.mocked(buildRouteEntry).mockReturnValueOnce({
+      routePath: '/dashboard',
+      isDynamic: false,
+      isCatchAll: false,
+    } as ReturnType<typeof buildRouteEntry>)
+
+    const config = makeConfig({ ssg: { concurrency: 1 } } as Partial<ResolvedCerConfig>)
+    await buildSSG(config)
+
+    // buildRouteEntry should never be called — page is skipped before it
+    expect(buildRouteEntry).not.toHaveBeenCalled()
+  })
+
+  it('skips static page with render: spa', async () => {
+    vi.mocked(existsSync).mockReturnValue(true)
+    vi.mocked(fg).mockResolvedValue(['/project/app/pages/profile.ts'])
+    vi.mocked(readFile).mockResolvedValue("export const meta = { render: 'spa' }")
+    vi.mocked(buildRouteEntry).mockReturnValueOnce({
+      routePath: '/profile',
+      isDynamic: false,
+      isCatchAll: false,
+    } as ReturnType<typeof buildRouteEntry>)
+
+    const config = makeConfig({ ssg: { concurrency: 1 } } as Partial<ResolvedCerConfig>)
+    await buildSSG(config)
+
+    expect(buildRouteEntry).not.toHaveBeenCalled()
+  })
+
+  it('does not skip static page with render: static', async () => {
+    vi.mocked(existsSync).mockReturnValue(true)
+    vi.mocked(fg).mockResolvedValue(['/project/app/pages/legal.ts'])
+    vi.mocked(readFile).mockResolvedValue("export const meta = { render: 'static' }")
+    vi.mocked(buildRouteEntry).mockReturnValueOnce({
+      routePath: '/legal',
+      isDynamic: false,
+      isCatchAll: false,
+    } as ReturnType<typeof buildRouteEntry>)
+
+    await buildSSG(makeConfig())
+
+    expect(buildRouteEntry).toHaveBeenCalledTimes(1)
+  })
+
+  it('does not skip static page with no render meta', async () => {
+    vi.mocked(existsSync).mockReturnValue(true)
+    vi.mocked(fg).mockResolvedValue(['/project/app/pages/about.ts'])
+    vi.mocked(readFile).mockResolvedValue("component('page-about', () => html`<h1>About</h1>`)")
+    vi.mocked(buildRouteEntry).mockReturnValueOnce({
+      routePath: '/about',
+      isDynamic: false,
+      isCatchAll: false,
+    } as ReturnType<typeof buildRouteEntry>)
+
+    await buildSSG(makeConfig())
+
+    expect(buildRouteEntry).toHaveBeenCalledTimes(1)
+  })
+})
+
+describe('buildSSG — render strategy skip (dynamic pages)', () => {
+  it('skips dynamic page with render: server from ssrLoadModule', async () => {
+    vi.mocked(existsSync).mockReturnValue(true)
+    vi.mocked(fg).mockResolvedValue(['/project/app/pages/[slug].ts'])
+    vi.mocked(readFile).mockResolvedValue('')
+    vi.mocked(buildRouteEntry).mockReturnValueOnce({
+      routePath: '/:slug',
+      isDynamic: true,
+      isCatchAll: false,
+    } as ReturnType<typeof buildRouteEntry>)
+
+    const closeFn = vi.fn().mockResolvedValue(undefined)
+    vi.mocked(createServer).mockResolvedValue({
+      ssrLoadModule: vi.fn().mockResolvedValue({ meta: { render: 'server' } }),
+      close: closeFn,
+    } as unknown as Awaited<ReturnType<typeof createServer>>)
+
+    const config = makeConfig({ ssg: { concurrency: 1 } } as Partial<ResolvedCerConfig>)
+    await buildSSG(config)
+
+    // Only '/' (always added) — the dynamic route was skipped
+    const manifestCall = vi.mocked(writeFile).mock.calls.find(([p]) =>
+      String(p).includes('ssg-manifest.json'),
+    )
+    const manifest = JSON.parse(String(manifestCall![1]))
+    expect(manifest.paths.length + manifest.errors.length).toBe(1)
+  })
+
+  it('skips dynamic page with render: spa from ssrLoadModule', async () => {
+    vi.mocked(existsSync).mockReturnValue(true)
+    vi.mocked(fg).mockResolvedValue(['/project/app/pages/[id].ts'])
+    vi.mocked(readFile).mockResolvedValue('')
+    vi.mocked(buildRouteEntry).mockReturnValueOnce({
+      routePath: '/:id',
+      isDynamic: true,
+      isCatchAll: false,
+    } as ReturnType<typeof buildRouteEntry>)
+
+    const closeFn = vi.fn().mockResolvedValue(undefined)
+    vi.mocked(createServer).mockResolvedValue({
+      ssrLoadModule: vi.fn().mockResolvedValue({ meta: { render: 'spa' } }),
+      close: closeFn,
+    } as unknown as Awaited<ReturnType<typeof createServer>>)
+
+    const config = makeConfig({ ssg: { concurrency: 1 } } as Partial<ResolvedCerConfig>)
+    await buildSSG(config)
+
+    const manifestCall = vi.mocked(writeFile).mock.calls.find(([p]) =>
+      String(p).includes('ssg-manifest.json'),
+    )
+    const manifest = JSON.parse(String(manifestCall![1]))
+    expect(manifest.paths.length + manifest.errors.length).toBe(1)
+  })
+})
+
 // ─── writeRenderedPath ────────────────────────────────────────────────────────
 
 describe('writeRenderedPath', () => {

package/src/__tests__/plugin/dev-server.test.ts

@@ -464,6 +464,97 @@ describe('configureCerDevServer — SSR mode', () => {
   })
 })
 
+// ─── Per-route render mode (SSR mode) ────────────────────────────────────────
+
+describe("configureCerDevServer — per-route render mode in SSR", () => {
+  /** Build a server where virtual:cer-routes returns the given routes array. */
+  function makeServerWithRoutes(
+    pageRoutes: Array<{ path: string; meta?: Record<string, unknown> }>,
+    ssrHandler = vi.fn(async (_req: any, res: any) => res.end('<html>SSR</html>')),
+  ) {
+    const { server, getMiddleware } = makeServer()
+    server.ssrLoadModule.mockImplementation(async (path: string) => {
+      if (path.includes('server-middleware')) return { serverMiddleware: [] }
+      if (path.includes('server-api') || path.includes('cer-server-api')) return { apiRoutes: [] }
+      if (path.includes('cer-routes')) return { default: pageRoutes }
+      return { handler: ssrHandler }
+    })
+    configureCerDevServer(server as any, makeConfig({ mode: 'ssr' }))
+    return { middleware: getMiddleware(), ssrHandler }
+  }
+
+  it("calls next() instead of SSR for a route with render: 'spa'", async () => {
+    const { middleware, ssrHandler } = makeServerWithRoutes([
+      { path: '/spa-page', meta: { render: 'spa' } },
+    ])
+    const next = vi.fn()
+    await middleware(
+      createReq({ url: '/spa-page', headers: { accept: 'text/html' } }),
+      createRes(),
+      next,
+    )
+    expect(next).toHaveBeenCalled()
+    expect(ssrHandler).not.toHaveBeenCalled()
+  })
+
+  it("proceeds to SSR for a route with render: 'server'", async () => {
+    const { middleware, ssrHandler } = makeServerWithRoutes([
+      { path: '/server-page', meta: { render: 'server' } },
+    ])
+    await middleware(
+      createReq({ url: '/server-page', headers: { accept: 'text/html' } }),
+      createRes(),
+      vi.fn(),
+    )
+    expect(ssrHandler).toHaveBeenCalled()
+  })
+
+  it("proceeds to SSR for a route with no render meta", async () => {
+    const { middleware, ssrHandler } = makeServerWithRoutes([
+      { path: '/normal-page' },
+    ])
+    await middleware(
+      createReq({ url: '/normal-page', headers: { accept: 'text/html' } }),
+      createRes(),
+      vi.fn(),
+    )
+    expect(ssrHandler).toHaveBeenCalled()
+  })
+
+  it("falls back to SSR when routes module throws during render mode check", async () => {
+    const ssrHandler = vi.fn(async (_req: any, res: any) => res.end('<html>SSR</html>'))
+    const { server, getMiddleware } = makeServer()
+    server.ssrLoadModule.mockImplementation(async (path: string) => {
+      if (path.includes('server-middleware')) return { serverMiddleware: [] }
+      if (path.includes('server-api') || path.includes('cer-server-api')) return { apiRoutes: [] }
+      if (path.includes('cer-routes')) throw new Error('module not ready')
+      return { handler: ssrHandler }
+    })
+    configureCerDevServer(server as any, makeConfig({ mode: 'ssr' }))
+    await getMiddleware()(
+      createReq({ url: '/some-page', headers: { accept: 'text/html' } }),
+      createRes(),
+      vi.fn(),
+    )
+    // Despite the routes module throwing, SSR should still run
+    expect(ssrHandler).toHaveBeenCalled()
+  })
+
+  it("does not load routes module in SPA mode (no render mode check needed)", async () => {
+    const { server, getMiddleware } = makeServer()
+    configureCerDevServer(server as any, makeConfig({ mode: 'spa' }))
+    await getMiddleware()(
+      createReq({ url: '/about', headers: { accept: 'text/html' } }),
+      createRes(),
+      vi.fn(),
+    )
+    const routesCalls = (server.ssrLoadModule as any).mock.calls.filter(
+      ([p]: [string]) => p.includes('cer-routes'),
+    )
+    expect(routesCalls).toHaveLength(0)
+  })
+})
+
 // ─── parseBody edge cases ─────────────────────────────────────────────────────
 
 describe('configureCerDevServer — malformed JSON body', () => {

package/src/__tests__/plugin/entry-server-template.test.ts

@@ -142,4 +142,57 @@ describe('entry-server-template (ENTRY_SERVER_TEMPLATE content)', () => {
     expect(src).toContain('stream.getReader()')
     expect(src).toContain('reader.read()')
   })
+
+  // ─── Error boundary ──────────────────────────────────────────────────────────
+
+  it('imports errorTag from virtual:cer-error', () => {
+    expect(src).toContain('errorTag')
+    expect(src).toContain('virtual:cer-error')
+  })
+
+  it('catches loader errors in _prepareRequest', () => {
+    expect(src).toContain('catch (err)')
+    // The catch block is inside _prepareRequest, before the layout chain
+    const catchIdx = src.indexOf('catch (err)')
+    const prepareIdx = src.indexOf('_prepareRequest')
+    expect(catchIdx).toBeGreaterThan(prepareIdx)
+  })
+
+  it('extracts .status from the thrown error for HTTP status code', () => {
+    expect(src).toContain("'status' in err")
+    expect(src).toContain('err.status')
+  })
+
+  it('defaults to status 500 when thrown error has no .status', () => {
+    expect(src).toContain(': 500')
+  })
+
+  it('renders errorTag component when loader throws and errorTag is set', () => {
+    expect(src).toContain('tag: errorTag')
+  })
+
+  it('logs to console.error when loader throws and no errorTag is defined', () => {
+    expect(src).toContain('console.error')
+    expect(src).toContain('!errorTag')
+  })
+
+  it('propagates status to res.statusCode', () => {
+    expect(src).toContain('res.statusCode = status')
+  })
+
+  it('returns status: null on the happy path', () => {
+    expect(src).toContain('status: null')
+  })
+
+  // ─── ISR production export ───────────────────────────────────────────────────
+
+  it('imports createIsrHandler from the isr subpath', () => {
+    expect(src).toContain('createIsrHandler')
+    expect(src).toContain('vite-plugin-cer-app/isr')
+  })
+
+  it('exports isrHandler wrapping handler with ISR caching', () => {
+    expect(src).toContain('export const isrHandler')
+    expect(src).toContain('createIsrHandler(routes, handler)')
+  })
 })

package/src/__tests__/plugin/virtual/routes.test.ts

@@ -335,6 +335,71 @@ describe('generateRoutesCode — meta.transition', () => {
   })
 })
 
+// ─── meta.render ──────────────────────────────────────────────────────────────
+
+describe('generateRoutesCode — meta.render', () => {
+  beforeEach(() => {
+    vi.mocked(existsSync).mockReturnValue(true)
+    vi.mocked(scanDirectory).mockResolvedValue([])
+    vi.mocked(readFile).mockResolvedValue('' as never)
+  })
+
+  it('emits meta.render "server" when declared', async () => {
+    vi.mocked(scanDirectory).mockResolvedValue([`${PAGES}/dashboard.ts`])
+    vi.mocked(readFile).mockResolvedValue(
+      `export const meta = { render: 'server' }` as never,
+    )
+    const code = await generateRoutesCode(PAGES)
+    expect(code).toContain('render: "server"')
+  })
+
+  it('emits meta.render "spa" when declared', async () => {
+    vi.mocked(scanDirectory).mockResolvedValue([`${PAGES}/profile.ts`])
+    vi.mocked(readFile).mockResolvedValue(
+      `export const meta = { render: 'spa' }` as never,
+    )
+    const code = await generateRoutesCode(PAGES)
+    expect(code).toContain('render: "spa"')
+  })
+
+  it('emits meta.render "static" when declared', async () => {
+    vi.mocked(scanDirectory).mockResolvedValue([`${PAGES}/about.ts`])
+    vi.mocked(readFile).mockResolvedValue(
+      `export const meta = { render: 'static' }` as never,
+    )
+    const code = await generateRoutesCode(PAGES)
+    expect(code).toContain('render: "static"')
+  })
+
+  it('omits render meta when not declared', async () => {
+    vi.mocked(scanDirectory).mockResolvedValue([`${PAGES}/about.ts`])
+    vi.mocked(readFile).mockResolvedValue(
+      `component('page-about', () => html\`<h1>About</h1>\`)` as never,
+    )
+    const code = await generateRoutesCode(PAGES)
+    expect(code).not.toContain('render:')
+  })
+
+  it('ignores unknown render values', async () => {
+    vi.mocked(scanDirectory).mockResolvedValue([`${PAGES}/about.ts`])
+    vi.mocked(readFile).mockResolvedValue(
+      `export const meta = { render: 'unknown' }` as never,
+    )
+    const code = await generateRoutesCode(PAGES)
+    expect(code).not.toContain('render:')
+  })
+
+  it('can combine render with layout', async () => {
+    vi.mocked(scanDirectory).mockResolvedValue([`${PAGES}/dashboard.ts`])
+    vi.mocked(readFile).mockResolvedValue(
+      `export const meta = { render: 'server', layout: 'admin' }` as never,
+    )
+    const code = await generateRoutesCode(PAGES)
+    expect(code).toContain('render: "server"')
+    expect(code).toContain('layout: "admin"')
+  })
+})
+
 // ─── nested layouts (layoutChain) ────────────────────────────────────────────
 
 describe('generateRoutesCode — layoutChain (nested layouts)', () => {