@jasonshimmy/vite-plugin-cer-app 0.1.1 → 0.1.2

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

@@ -0,0 +1,265 @@
+import { vi, describe, it, expect, beforeEach } from 'vitest'
+
+vi.mock('node:fs', () => ({ existsSync: vi.fn().mockReturnValue(false) }))
+vi.mock('node:fs/promises', () => ({
+  writeFile: vi.fn().mockResolvedValue(undefined),
+  mkdir: vi.fn().mockResolvedValue(undefined),
+}))
+vi.mock('fast-glob', () => ({ default: vi.fn().mockResolvedValue([]) }))
+vi.mock('vite', () => ({
+  build: vi.fn().mockResolvedValue(undefined),
+  createServer: vi.fn(),
+}))
+vi.mock('../../plugin/build-ssr.js', () => ({ buildSSR: vi.fn().mockResolvedValue(undefined) }))
+vi.mock('../../plugin/path-utils.js', () => ({ buildRouteEntry: vi.fn() }))
+
+import { existsSync } from 'node:fs'
+import { writeFile, mkdir } from 'node:fs/promises'
+import fg from 'fast-glob'
+import { createServer } from 'vite'
+import { buildSSR } from '../../plugin/build-ssr.js'
+import { buildRouteEntry } from '../../plugin/path-utils.js'
+import { buildSSG } from '../../plugin/build-ssg.js'
+import type { ResolvedCerConfig } from '../../plugin/dev-server.js'
+
+function makeConfig(overrides: Partial<ResolvedCerConfig> = {}): ResolvedCerConfig {
+  return {
+    root: '/project',
+    srcDir: '/project/app',
+    pagesDir: '/project/app/pages',
+    mode: 'ssg',
+    ssr: { dsd: true },
+    ssg: { concurrency: 4 },
+    ...overrides,
+  } as unknown as ResolvedCerConfig
+}
+
+beforeEach(() => {
+  vi.mocked(buildSSR).mockClear()
+  vi.mocked(writeFile).mockClear()
+  vi.mocked(mkdir).mockClear()
+  vi.mocked(fg).mockClear()
+  vi.mocked(existsSync).mockReturnValue(false)
+  vi.mocked(fg).mockResolvedValue([])
+  vi.mocked(buildRouteEntry).mockReset()
+})
+
+describe('buildSSG — buildSSR delegation', () => {
+  it('calls buildSSR as step 1', async () => {
+    await buildSSG(makeConfig())
+    expect(buildSSR).toHaveBeenCalledTimes(1)
+  })
+
+  it('passes the config to buildSSR', async () => {
+    const config = makeConfig()
+    await buildSSG(config)
+    expect(vi.mocked(buildSSR).mock.calls[0][0]).toBe(config)
+  })
+})
+
+describe('buildSSG — ssg-manifest.json', () => {
+  it('writes ssg-manifest.json to the dist directory', async () => {
+    await buildSSG(makeConfig())
+    const manifestCall = vi.mocked(writeFile).mock.calls.find(([path]) =>
+      String(path).includes('ssg-manifest.json'),
+    )
+    expect(manifestCall).toBeDefined()
+    expect(String(manifestCall![0])).toContain('/project/dist/ssg-manifest.json')
+  })
+
+  it('manifest JSON contains generatedAt field', async () => {
+    await buildSSG(makeConfig())
+    const manifestCall = vi.mocked(writeFile).mock.calls.find(([p]) =>
+      String(p).includes('ssg-manifest.json'),
+    )
+    const manifest = JSON.parse(String(manifestCall![1]))
+    expect(manifest).toHaveProperty('generatedAt')
+    expect(typeof manifest.generatedAt).toBe('string')
+  })
+
+  it('manifest JSON contains paths array', async () => {
+    await buildSSG(makeConfig())
+    const manifestCall = vi.mocked(writeFile).mock.calls.find(([p]) =>
+      String(p).includes('ssg-manifest.json'),
+    )
+    const manifest = JSON.parse(String(manifestCall![1]))
+    expect(manifest).toHaveProperty('paths')
+    expect(Array.isArray(manifest.paths)).toBe(true)
+  })
+
+  it('manifest JSON contains errors array', async () => {
+    await buildSSG(makeConfig())
+    const manifestCall = vi.mocked(writeFile).mock.calls.find(([p]) =>
+      String(p).includes('ssg-manifest.json'),
+    )
+    const manifest = JSON.parse(String(manifestCall![1]))
+    expect(manifest).toHaveProperty('errors')
+    expect(Array.isArray(manifest.errors)).toBe(true)
+  })
+
+  it('records render errors in manifest (missing server bundle)', async () => {
+    const config = makeConfig({ ssg: { routes: ['/about'], 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]))
+    // paths + errors together must cover every route we attempted to render
+    expect(manifest.paths.length + manifest.errors.length).toBe(1)
+  })
+
+  it('error entries have path and error fields', async () => {
+    const config = makeConfig({ ssg: { routes: ['/fail'], 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]))
+    if (manifest.errors.length > 0) {
+      expect(manifest.errors[0]).toHaveProperty('path')
+      expect(manifest.errors[0]).toHaveProperty('error')
+    }
+  })
+})
+
+describe('buildSSG — path collection', () => {
+  it('uses ssg.routes when explicitly provided (skips auto-discovery)', async () => {
+    const config = makeConfig({
+      ssg: { routes: ['/a', '/b'], concurrency: 1 },
+    } as Partial<ResolvedCerConfig>)
+    await buildSSG(config)
+    // fast-glob should NOT have been called — routes are explicit
+    expect(fg).not.toHaveBeenCalled()
+  })
+
+  it('calls fg when pagesDir exists and no explicit routes', async () => {
+    vi.mocked(existsSync).mockReturnValue(true)
+    await buildSSG(makeConfig())
+    expect(fg).toHaveBeenCalledTimes(1)
+  })
+
+  it('skips Vite dev server when all discovered pages are static', async () => {
+    vi.mocked(existsSync).mockReturnValue(true)
+    vi.mocked(fg).mockResolvedValue([
+      '/project/app/pages/index.ts',
+      '/project/app/pages/about.ts',
+    ])
+    vi.mocked(buildRouteEntry)
+      .mockReturnValueOnce({ routePath: '/', isDynamic: false, isCatchAll: false } as ReturnType<typeof buildRouteEntry>)
+      .mockReturnValueOnce({ routePath: '/about', isDynamic: false, isCatchAll: false } as ReturnType<typeof buildRouteEntry>)
+
+    await buildSSG(makeConfig())
+
+    expect(createServer).not.toHaveBeenCalled()
+  })
+
+  it('spawns Vite dev server for dynamic pages', async () => {
+    vi.mocked(existsSync).mockReturnValue(true)
+    vi.mocked(fg).mockResolvedValue(['/project/app/pages/[slug].ts'])
+    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({}),
+      close: closeFn,
+    } as unknown as Awaited<ReturnType<typeof createServer>>)
+
+    await buildSSG(makeConfig())
+
+    expect(createServer).toHaveBeenCalledTimes(1)
+    expect(closeFn).toHaveBeenCalledTimes(1)
+  })
+
+  it('closes Vite dev server even when ssrLoadModule throws', async () => {
+    vi.mocked(existsSync).mockReturnValue(true)
+    vi.mocked(fg).mockResolvedValue(['/project/app/pages/[slug].ts'])
+    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().mockRejectedValue(new Error('load failed')),
+      close: closeFn,
+    } as unknown as Awaited<ReturnType<typeof createServer>>)
+
+    await buildSSG(makeConfig())
+
+    expect(closeFn).toHaveBeenCalledTimes(1)
+  })
+
+  it('expands dynamic ssg.paths into concrete URL paths', async () => {
+    vi.mocked(existsSync).mockReturnValue(true)
+    vi.mocked(fg).mockResolvedValue(['/project/app/pages/[id].ts'])
+    vi.mocked(buildRouteEntry).mockReturnValueOnce({
+      routePath: '/:id',
+      isDynamic: true,
+      isCatchAll: false,
+    } as ReturnType<typeof buildRouteEntry>)
+
+    const ssgPathsFn = vi.fn().mockResolvedValue([
+      { params: { id: '1' } },
+      { params: { id: '2' } },
+    ])
+    const closeFn = vi.fn().mockResolvedValue(undefined)
+    vi.mocked(createServer).mockResolvedValue({
+      ssrLoadModule: vi.fn().mockResolvedValue({ meta: { ssg: { paths: ssgPathsFn } } }),
+      close: closeFn,
+    } as unknown as Awaited<ReturnType<typeof createServer>>)
+
+    const config = makeConfig({ ssg: { concurrency: 1 } } as Partial<ResolvedCerConfig>)
+    await buildSSG(config)
+
+    // The manifest should attempt to render '/', '/1', '/2' (3 paths total)
+    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(3)
+  })
+
+  it('skips catch-all pages when auto-discovering paths', async () => {
+    vi.mocked(existsSync).mockReturnValue(true)
+    vi.mocked(fg).mockResolvedValue(['/project/app/pages/[...all].ts'])
+    vi.mocked(buildRouteEntry).mockReturnValueOnce({
+      routePath: '/:all*',
+      isDynamic: true,
+      isCatchAll: true,
+    } as ReturnType<typeof buildRouteEntry>)
+
+    await buildSSG(makeConfig())
+
+    // Only '/' (always added) should be attempted
+    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('deduplicates collected paths', async () => {
+    vi.mocked(existsSync).mockReturnValue(true)
+    vi.mocked(fg).mockResolvedValue([
+      '/project/app/pages/index.ts',
+      '/project/app/pages/home.ts',
+    ])
+    // Both resolve to '/' — should deduplicate to a single path
+    vi.mocked(buildRouteEntry)
+      .mockReturnValueOnce({ routePath: '/', isDynamic: false, isCatchAll: false } as ReturnType<typeof buildRouteEntry>)
+      .mockReturnValueOnce({ routePath: '/', isDynamic: false, isCatchAll: false } as ReturnType<typeof buildRouteEntry>)
+
+    await buildSSG(makeConfig({ ssg: { concurrency: 1 } } as Partial<ResolvedCerConfig>))
+
+    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)
+  })
+})

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

@@ -0,0 +1,180 @@
+import { vi, describe, it, expect, beforeEach } from 'vitest'
+import { readFileSync } from 'node:fs'
+import { resolve } from 'pathe'
+
+// We test the server entry code generation by importing just that function.
+// The `buildSSR` function itself invokes Vite's `build` API which we don't
+// need to exercise in unit tests (it's an integration concern).
+vi.mock('vite', () => ({ build: vi.fn().mockResolvedValue(undefined) }))
+// Partial mock: keep the real readFileSync/existsSync but allow overrides in
+// individual describe blocks if needed.
+vi.mock('node:fs', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('node:fs')>()
+  return { ...actual, existsSync: vi.fn().mockReturnValue(true) }
+})
+
+import type { ResolvedCerConfig } from '../../plugin/dev-server.js'
+
+// Build a minimal ResolvedCerConfig so we can call generateServerEntryCode
+// without spinning up a real Vite build.
+function makeConfig(overrides: Partial<ResolvedCerConfig> = {}): ResolvedCerConfig {
+  return {
+    root: '/project',
+    srcDir: '/project/app',
+    mode: 'ssr',
+    ssr: { dsd: true },
+    ssg: { paths: [], concurrency: 4 },
+    ...overrides,
+  } as unknown as ResolvedCerConfig
+}
+
+describe('build-ssr generateServerEntryCode (template content)', () => {
+  // Read the source of build-ssr.ts to assert it contains the expected
+  // generated code strings.  This is intentionally coarse-grained:
+  // we check that the template emits the right imports, exports, and
+  // structural elements rather than testing every character.
+  const src = readFileSync(
+    resolve(import.meta.dirname, '../../plugin/build-ssr.ts'),
+    'utf-8',
+  )
+
+  it('template imports registerBuiltinComponents from custom-elements-runtime', () => {
+    expect(src).toContain('registerBuiltinComponents')
+  })
+
+  it('template imports renderToStringWithJITCSS from ssr subpath', () => {
+    expect(src).toContain('renderToStringWithJITCSS')
+    expect(src).toContain('custom-elements-runtime/ssr')
+  })
+
+  it('template imports initRouter from router subpath', () => {
+    expect(src).toContain('initRouter')
+    expect(src).toContain('custom-elements-runtime/router')
+  })
+
+  it('template loads client index.html for merging', () => {
+    expect(src).toContain('_clientTemplate')
+    expect(src).toContain('../client/index.html')
+  })
+
+  it('template defines _mergeWithClientTemplate helper', () => {
+    expect(src).toContain('_mergeWithClientTemplate')
+  })
+
+  it('template defines _prepareRequest async function', () => {
+    expect(src).toContain('_prepareRequest')
+  })
+
+  it('template exports handler as both named and default export', () => {
+    expect(src).toContain('export const handler')
+    expect(src).toContain('export default handler')
+  })
+
+  it('template exports apiRoutes, plugins, and layouts', () => {
+    expect(src).toContain('export { apiRoutes, plugins, layouts }')
+  })
+
+  it('template sets globalThis.__CER_DATA__ synchronously before render', () => {
+    expect(src).toContain('globalThis).__CER_DATA__ = loaderData')
+  })
+
+  it('template deletes __CER_DATA__ after render', () => {
+    expect(src).toContain('delete (globalThis).__CER_DATA__')
+  })
+
+  it('template uses renderToStringWithJITCSSDSD (dsd always on)', () => {
+    expect(src).toContain('renderToStringWithJITCSSDSD')
+  })
+
+  it('template passes dsdPolyfill: false to suppress inline polyfill', () => {
+    expect(src).toContain('dsdPolyfill: false')
+  })
+
+  it('template calls registerEntityMap with entities.json', () => {
+    expect(src).toContain('registerEntityMap(entitiesJson)')
+    expect(src).toContain('entities.json')
+  })
+
+  it('template imports DSD_POLYFILL_SCRIPT and injects before </body>', () => {
+    expect(src).toContain('DSD_POLYFILL_SCRIPT')
+    expect(src).toContain("finalHtml.replace('</body>'")
+  })
+
+  it('template merges SSR html with client template when available', () => {
+    expect(src).toContain('_clientTemplate')
+    expect(src).toContain('_mergeWithClientTemplate(ssrHtml, _clientTemplate)')
+  })
+
+  it('template reads virtual:cer-routes', () => {
+    expect(src).toContain('virtual:cer-routes')
+  })
+
+  it('template reads virtual:cer-layouts', () => {
+    expect(src).toContain('virtual:cer-layouts')
+  })
+
+  it('template reads virtual:cer-plugins', () => {
+    expect(src).toContain('virtual:cer-plugins')
+  })
+
+  it('template reads virtual:cer-server-api', () => {
+    expect(src).toContain('virtual:cer-server-api')
+  })
+
+  it('template reads virtual:cer-components', () => {
+    expect(src).toContain('virtual:cer-components')
+  })
+
+  it('sets Content-Type header on response', () => {
+    expect(src).toContain('text/html; charset=utf-8')
+  })
+})
+
+describe('buildSSR', () => {
+  let buildMock: ReturnType<typeof vi.fn>
+  let buildSSR: (config: ResolvedCerConfig, userConfig?: Record<string, unknown>) => Promise<void>
+
+  beforeEach(async () => {
+    const { build } = await import('vite')
+    buildMock = vi.mocked(build)
+    buildMock.mockClear()
+    buildMock.mockResolvedValue(undefined as never)
+    ;({ buildSSR } = await import('../../plugin/build-ssr.js'))
+  })
+
+  it('calls vite build twice (client then server)', async () => {
+    await buildSSR(makeConfig())
+    expect(buildMock).toHaveBeenCalledTimes(2)
+  })
+
+  it('first build targets dist/client output dir', async () => {
+    await buildSSR(makeConfig())
+    const firstCall = buildMock.mock.calls[0][0] as Record<string, unknown>
+    expect((firstCall.build as Record<string, unknown>).outDir).toContain('dist/client')
+  })
+
+  it('second build targets dist/server output dir', async () => {
+    await buildSSR(makeConfig())
+    const secondCall = buildMock.mock.calls[1][0] as Record<string, unknown>
+    expect((secondCall.build as Record<string, unknown>).outDir).toContain('dist/server')
+  })
+
+  it('second build has ssr:true', async () => {
+    await buildSSR(makeConfig())
+    const secondCall = buildMock.mock.calls[1][0] as Record<string, unknown>
+    expect((secondCall.build as Record<string, unknown>).ssr).toBe(true)
+  })
+
+  it('server bundle entry file is named server.js', async () => {
+    await buildSSR(makeConfig())
+    const secondCall = buildMock.mock.calls[1][0] as Record<string, unknown>
+    const rollup = (secondCall.build as Record<string, unknown>).rollupOptions as Record<string, unknown>
+    expect((rollup.output as Record<string, unknown>).entryFileNames).toBe('server.js')
+  })
+
+  it('merges user viteUserConfig into client build', async () => {
+    await buildSSR(makeConfig(), { define: { MY_FLAG: 'true' } })
+    const firstCall = buildMock.mock.calls[0][0] as Record<string, unknown>
+    expect(firstCall.define).toEqual({ MY_FLAG: 'true' })
+  })
+})