@jasonshimmy/vite-plugin-cer-app 0.23.1 → 0.24.0

package/e2e/kitchen-sink/server/data/posts.ts

@@ -1,21 +0,0 @@
-export interface Post {
-  slug: string
-  title: string
-  excerpt: string
-  body: string
-}
-
-export const posts: Post[] = [
-  {
-    slug: 'first-post',
-    title: 'First Post',
-    excerpt: 'The very first post in the kitchen sink.',
-    body: 'First post body content. This was loaded via a page loader.',
-  },
-  {
-    slug: 'second-post',
-    title: 'Second Post',
-    excerpt: 'The second post in the kitchen sink.',
-    body: 'Second post body content. Dynamic routes and loaders work together.',
-  },
-]

package/e2e/kitchen-sink/server/middleware/01-headers.ts

@@ -1,6 +0,0 @@
-// Server middleware — adds a custom header to every response so e2e tests
-// can verify that the server middleware chain ran correctly.
-export default defineServerMiddleware((_req, res, next) => {
-  res.setHeader('X-CER-Middleware', 'active')
-  next()
-})

package/e2e/kitchen-sink/server/middleware/02-status-test.ts

@@ -1,10 +0,0 @@
-// P1-2: Server middleware that throws a custom status code.
-// Only triggers for requests to /middleware-status-test.
-export default defineServerMiddleware((req, _res, next) => {
-  if (req.url === '/middleware-status-test') {
-    const err = new Error('Unauthorized') as Error & { status: number }
-    err.status = 401
-    throw err
-  }
-  next()
-})

package/e2e/kitchen-sink/tsconfig.json

@@ -1,3 +0,0 @@
-{
-  "extends": "./.cer/tsconfig.json"
-}

package/e2e/scripts/clean.mjs

@@ -1,14 +0,0 @@
-import { rmSync } from 'node:fs'
-import { fileURLToPath } from 'node:url'
-import { join } from 'node:path'
-
-const root = fileURLToPath(new URL('../kitchen-sink', import.meta.url))
-rmSync(join(root, 'dist'), { recursive: true, force: true })
-rmSync(join(root, 'node_modules', '.cer-app-cache'), { recursive: true, force: true })
-// Adapter outputs — cleaned so every test run starts from a known state.
-rmSync(join(root, '.netlify'), { recursive: true, force: true })
-rmSync(join(root, 'netlify'), { recursive: true, force: true })
-rmSync(join(root, '.vercel'), { recursive: true, force: true })
-// Cloudflare: _worker.js sits inside dist/ (cleaned above); wrangler.toml at root.
-rmSync(join(root, 'wrangler.toml'), { force: true })
-console.log('[e2e] Cleaned kitchen-sink/dist, cache, and adapter outputs')

package/eslint.config.ts

@@ -1,22 +0,0 @@
-import tseslint from 'typescript-eslint'
-
-export default tseslint.config(
-  {
-    ignores: [
-      'dist/**',
-      'node_modules/**',
-      'coverage/**',
-      'e2e/**',
-      'src/__tests__/**',
-      'src/cli/create/templates/**',
-    ],
-  },
-  {
-    files: ['src/**/*.ts'],
-    extends: [...tseslint.configs.recommended],
-    rules: {
-      '@typescript-eslint/no-explicit-any': 'error',
-      '@typescript-eslint/no-unused-vars': ['error', { argsIgnorePattern: '^_', varsIgnorePattern: '^_' }],
-    },
-  },
-)

package/src/__tests__/cli/adapters/cloudflare-worker.integration.test.ts

@@ -1,132 +0,0 @@
-/**
- * Cloudflare Pages worker — integration tests.
- *
- * These tests exercise the full request/response pipeline through the generated
- * `dist/_worker.js`: Web API Request → server middleware → API route handler
- * / SSR handler → streaming Web API Response (TransformStream body).
- *
- * Prerequisites (run automatically via `npm run e2e:integration:cloudflare`):
- *   1. `cer-app build --mode ssr --root e2e/kitchen-sink`
- *   2. `cer-app adapt --platform cloudflare --root e2e/kitchen-sink`
- *
- * When the worker does not exist (e.g. during a normal `npm test` run) the
- * entire suite is skipped — no failures, no noise.
- */
-
-import { describe, it, expect, beforeAll } from 'vitest'
-import { existsSync } from 'node:fs'
-import { resolve } from 'pathe'
-
-// ─── Paths ────────────────────────────────────────────────────────────────────
-
-const KITCHEN_SINK = resolve(import.meta.dirname, '../../../../e2e/kitchen-sink')
-const WORKER_PATH = resolve(KITCHEN_SINK, 'dist/_worker.js')
-const SERVER_BUNDLE = resolve(KITCHEN_SINK, 'dist/server/server.js')
-const workerExists = existsSync(WORKER_PATH) && existsSync(SERVER_BUNDLE)
-
-// ─── Suite ───────────────────────────────────────────────────────────────────
-
-describe.skipIf(!workerExists)('Cloudflare Pages worker — integration', () => {
-  type WorkerModule = { default: { fetch(req: Request, env?: unknown, ctx?: unknown): Promise<Response> } }
-  let worker: WorkerModule['default']
-
-  beforeAll(async () => {
-    const mod = await import(WORKER_PATH) as WorkerModule
-    worker = mod.default
-  })
-
-  const call = (path: string, init?: RequestInit) =>
-    worker.fetch(new Request(`http://localhost${path}`, init))
-
-  // ─── HTML rendering ────────────────────────────────────────────────────────
-
-  it('GET / returns 200 with Content-Type text/html', async () => {
-    const res = await call('/')
-    expect(res.status).toBe(200)
-    expect(res.headers.get('content-type')).toContain('text/html')
-  })
-
-  it('GET / response is a complete HTML document streamed via ReadableStream', async () => {
-    const res = await call('/')
-    // Response body is a ReadableStream (streaming, not pre-buffered).
-    expect(res.body).toBeInstanceOf(ReadableStream)
-    const body = await res.text()
-    expect(body).toContain('<!DOCTYPE html')
-    expect(body).toContain('</html>')
-  })
-
-  it('GET / SSR body includes kitchen-sink content', async () => {
-    const res = await call('/')
-    const body = await res.text()
-    expect(body).toContain('Kitchen Sink')
-  })
-
-  it('GET /about returns 200 HTML', async () => {
-    const res = await call('/about')
-    expect(res.status).toBe(200)
-    const body = await res.text()
-    expect(body).toContain('<!DOCTYPE html')
-  })
-
-  // ─── API routes ───────────────────────────────────────────────────────────
-
-  it('GET /api/health returns 200 JSON {status:"ok"}', async () => {
-    const res = await call('/api/health')
-    expect(res.status).toBe(200)
-    expect(res.headers.get('content-type')).toContain('application/json')
-    const data = await res.json() as { status: string; service: string }
-    expect(data.status).toBe('ok')
-    expect(data.service).toBe('kitchen-sink')
-  })
-
-  it('GET /api/posts returns 200 JSON array', async () => {
-    const res = await call('/api/posts')
-    expect(res.status).toBe(200)
-    const data = await res.json() as unknown[]
-    expect(Array.isArray(data)).toBe(true)
-    expect(data.length).toBeGreaterThan(0)
-  })
-
-  it('GET /api/posts/:slug returns the matching post', async () => {
-    const res = await call('/api/posts/first-post')
-    expect(res.status).toBe(200)
-    const post = await res.json() as { slug: string; title: string }
-    expect(post.slug).toBe('first-post')
-  })
-
-  it('GET /api/posts/:slug returns 404 for unknown slug', async () => {
-    const res = await call('/api/posts/does-not-exist')
-    expect(res.status).toBe(404)
-  })
-
-  it('GET /api/unknown-route returns 404', async () => {
-    const res = await call('/api/unknown-route')
-    expect(res.status).toBe(404)
-  })
-
-  // ─── Server middleware ────────────────────────────────────────────────────
-
-  it('server middleware injects X-CER-Middleware header', async () => {
-    const res = await call('/')
-    expect(res.headers.get('x-cer-middleware')).toBe('active')
-  })
-
-  it('server middleware runs before API routes (header on /api/health)', async () => {
-    const res = await call('/api/health')
-    expect(res.headers.get('x-cer-middleware')).toBe('active')
-  })
-
-  // ─── Response integrity ───────────────────────────────────────────────────
-
-  it('API response body is valid JSON (not truncated)', async () => {
-    const res = await call('/api/posts')
-    const text = await res.text()
-    expect(() => JSON.parse(text)).not.toThrow()
-  })
-
-  it('HTML response body is not empty', async () => {
-    const res = await call('/')
-    const body = await res.text()
-    expect(body.length).toBeGreaterThan(100)
-  })
-})

package/src/__tests__/cli/adapters/cloudflare.test.ts

@@ -1,332 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'
-import { mkdirSync, writeFileSync, readFileSync, existsSync, rmSync } from 'node:fs'
-import { join } from 'pathe'
-import { tmpdir } from 'node:os'
-import { runCloudflareAdapter } from '../../../cli/adapters/cloudflare.js'
-
-// ─── Helpers ──────────────────────────────────────────────────────────────────
-
-function createTempRoot(): string {
-  const dir = join(tmpdir(), `cer-cf-test-${Date.now()}-${Math.random().toString(36).slice(2)}`)
-  mkdirSync(dir, { recursive: true })
-  return dir
-}
-
-function writeFile(root: string, rel: string, content = 'content'): void {
-  const full = join(root, rel)
-  mkdirSync(join(full, '..'), { recursive: true })
-  writeFileSync(full, content)
-}
-
-function readText(root: string, rel: string): string {
-  return readFileSync(join(root, rel), 'utf-8')
-}
-
-// ─── SSR mode ────────────────────────────────────────────────────────────────
-
-describe('runCloudflareAdapter — SSR mode', () => {
-  let root: string
-
-  beforeEach(() => {
-    root = createTempRoot()
-    writeFile(root, 'dist/server/server.js', '// server bundle')
-    writeFile(root, 'dist/client/index.html', '<html><body>client shell</body></html>')
-    writeFile(root, 'dist/client/assets/main-abc.js', '// asset')
-    writeFile(root, 'dist/client/favicon.ico', 'ico')
-    // No ssg-manifest.json → SSR mode
-  })
-
-  afterEach(() => rmSync(root, { recursive: true, force: true }))
-
-  it('writes dist/_worker.js', async () => {
-    await runCloudflareAdapter(root)
-    expect(existsSync(join(root, 'dist/_worker.js'))).toBe(true)
-  })
-
-  it('worker imports from ./server/server.js', async () => {
-    await runCloudflareAdapter(root)
-    const worker = readText(root, 'dist/_worker.js')
-    expect(worker).toContain("await import('./server/server.js')")
-  })
-
-  it('worker exports a fetch handler (Cloudflare module format)', async () => {
-    await runCloudflareAdapter(root)
-    const worker = readText(root, 'dist/_worker.js')
-    expect(worker).toContain('export default')
-    expect(worker).toContain('async fetch(')
-  })
-
-  it('worker inlines the client HTML template via globalThis.__CER_CLIENT_TEMPLATE__', async () => {
-    await runCloudflareAdapter(root)
-    const worker = readText(root, 'dist/_worker.js')
-    expect(worker).toContain('globalThis.__CER_CLIENT_TEMPLATE__')
-    expect(worker).toContain('client shell')
-  })
-
-  it('worker uses top-level await dynamic import for server bundle', async () => {
-    await runCloudflareAdapter(root)
-    const worker = readText(root, 'dist/_worker.js')
-    expect(worker).toContain("await import('./server/server.js')")
-  })
-
-  it('worker imports Readable from node:stream (nodejs_compat)', async () => {
-    await runCloudflareAdapter(root)
-    const worker = readText(root, 'dist/_worker.js')
-    expect(worker).toContain("from 'node:stream'")
-    expect(worker).toContain('Readable')
-  })
-
-  it('worker imports isrHandler and uses it for SSR fallback (enables ISR stale-while-revalidate)', async () => {
-    await runCloudflareAdapter(root)
-    const worker = readText(root, 'dist/_worker.js')
-    expect(worker).toContain('isrHandler')
-    expect(worker).toContain('isrHandler(nodeReq, res)')
-  })
-
-  it('worker does not destructure unused handler export (only isrHandler is needed)', async () => {
-    await runCloudflareAdapter(root)
-    const worker = readText(root, 'dist/_worker.js')
-    // isrHandler wraps handler internally — the worker only needs isrHandler
-    expect(worker).not.toMatch(/\{\s*handler\s*,/)
-    expect(worker).not.toMatch(/,\s*handler\s*[,}]/)
-  })
-
-  it('worker handles /api/* routing via matchApiPattern', async () => {
-    await runCloudflareAdapter(root)
-    const worker = readText(root, 'dist/_worker.js')
-    expect(worker).toContain("urlPath.startsWith('/api/')")
-    expect(worker).toContain('matchApiPattern')
-    expect(worker).toContain('apiRoutes')
-  })
-
-  it('worker calls runServerMiddleware before dispatching', async () => {
-    await runCloudflareAdapter(root)
-    const worker = readText(root, 'dist/_worker.js')
-    expect(worker).toContain('runServerMiddleware')
-  })
-
-  it('worker mock res has writableEnded guard', async () => {
-    await runCloudflareAdapter(root)
-    const worker = readText(root, 'dist/_worker.js')
-    expect(worker).toContain('writableEnded')
-    expect(worker).toContain('if (_ended) return')
-  })
-
-  it('worker returns a streaming Web API Response (TransformStream body)', async () => {
-    await runCloudflareAdapter(root)
-    const worker = readText(root, 'dist/_worker.js')
-    expect(worker).toContain('new Response(readable,')
-    expect(worker).toContain('TransformStream')
-    expect(worker).not.toContain('Buffer.concat')
-  })
-
-  it('streaming Response carries status code and accumulated response headers', async () => {
-    await runCloudflareAdapter(root)
-    const worker = readText(root, 'dist/_worker.js')
-    // end() resolves with new Response(readable, { status: res.statusCode, headers })
-    expect(worker).toContain('res.statusCode')
-    expect(worker).toContain('{ status: res.statusCode, headers }')
-  })
-
-  it('worker streams chunks via writer.write() instead of buffering', async () => {
-    await runCloudflareAdapter(root)
-    const worker = readText(root, 'dist/_worker.js')
-    expect(worker).toContain('writer.write(')
-    expect(worker).toContain('writer.close()')
-  })
-
-  it('worker uses TextEncoder to convert string chunks to Uint8Array', async () => {
-    await runCloudflareAdapter(root)
-    const worker = readText(root, 'dist/_worker.js')
-    expect(worker).toContain('encoder.encode(chunk)')
-    expect(worker).toContain('new TextEncoder()')
-  })
-
-  it('worker silently swallows writer rejections to prevent UnhandledPromiseRejection on client disconnect', async () => {
-    await runCloudflareAdapter(root)
-    const worker = readText(root, 'dist/_worker.js')
-    expect(worker).toContain('.catch(() => {})')
-    expect(worker).toContain('writer.close().catch(() => {})')
-  })
-
-  it('worker wraps API handlers in runWithRequestContext for cookie/session access', async () => {
-    await runCloudflareAdapter(root)
-    const worker = readText(root, 'dist/_worker.js')
-    expect(worker).toContain('runWithRequestContext')
-    expect(worker).toContain('runWithRequestContext(nodeReq, res, () => Promise.resolve(fn(nodeReq, res)))')
-  })
-
-  it('worker attaches req.query (parsed query string) in toNodeRequest', async () => {
-    await runCloudflareAdapter(root)
-    const worker = readText(root, 'dist/_worker.js')
-    expect(worker).toContain('parseQuery')
-    expect(worker).toContain('req.query = parseQuery(')
-  })
-
-  it('worker attaches req.body (parsed JSON body) in toNodeRequest', async () => {
-    await runCloudflareAdapter(root)
-    const worker = readText(root, 'dist/_worker.js')
-    expect(worker).toContain('req.body =')
-    expect(worker).toContain("'application/json'")
-    expect(worker).toContain('JSON.parse(')
-  })
-
-  it('copies content-hashed assets to dist/assets/', async () => {
-    await runCloudflareAdapter(root)
-    expect(existsSync(join(root, 'dist/assets/main-abc.js'))).toBe(true)
-  })
-
-  it('copies other public files (favicon.ico) to dist/', async () => {
-    await runCloudflareAdapter(root)
-    expect(existsSync(join(root, 'dist/favicon.ico'))).toBe(true)
-  })
-
-  it('does NOT copy index.html to dist/ root (handled by SSR worker)', async () => {
-    await runCloudflareAdapter(root)
-    // The original dist/client/index.html should NOT be copied to dist/index.html
-    // (_worker.js handles all HTML requests)
-    const workerExists = existsSync(join(root, 'dist/_worker.js'))
-    expect(workerExists).toBe(true)
-    // index.html at dist root would clash with worker; confirm it's absent
-    expect(existsSync(join(root, 'dist/index.html'))).toBe(false)
-  })
-
-  it('writes wrangler.toml', async () => {
-    await runCloudflareAdapter(root)
-    expect(existsSync(join(root, 'wrangler.toml'))).toBe(true)
-  })
-
-  it('wrangler.toml includes nodejs_compat compatibility flag', async () => {
-    await runCloudflareAdapter(root)
-    const toml = readText(root, 'wrangler.toml')
-    expect(toml).toContain('nodejs_compat')
-    expect(toml).toContain('compatibility_flags')
-  })
-
-  it('wrangler.toml sets pages_build_output_dir to dist', async () => {
-    await runCloudflareAdapter(root)
-    const toml = readText(root, 'wrangler.toml')
-    expect(toml).toContain('dist')
-  })
-
-  it('throws if dist/ does not exist', async () => {
-    rmSync(join(root, 'dist'), { recursive: true, force: true })
-    await expect(runCloudflareAdapter(root)).rejects.toThrow("Run 'cer-app build' first")
-  })
-
-  it('worker escapes backticks in the inlined HTML', async () => {
-    writeFile(root, 'dist/client/index.html', '<script>const t = `hello`</script>')
-    await runCloudflareAdapter(root)
-    const worker = readText(root, 'dist/_worker.js')
-    // The backtick in the HTML must be escaped so the template literal stays valid
-    expect(worker).toContain('\\`hello\\`')
-  })
-
-  it('worker handles missing client HTML gracefully (empty string)', async () => {
-    rmSync(join(root, 'dist/client/index.html'))
-    await runCloudflareAdapter(root)
-    const worker = readText(root, 'dist/_worker.js')
-    // Empty string inlined — worker still generated without error
-    expect(worker).toContain('globalThis.__CER_CLIENT_TEMPLATE__')
-  })
-})
-
-// ─── SPA mode ────────────────────────────────────────────────────────────────
-
-describe('runCloudflareAdapter — SPA mode', () => {
-  let root: string
-
-  beforeEach(() => {
-    root = createTempRoot()
-    writeFile(root, 'dist/index.html', '<html>spa</html>')
-    writeFile(root, 'dist/assets/app-abc.js', '// app')
-  })
-
-  afterEach(() => rmSync(root, { recursive: true, force: true }))
-
-  it('does NOT write dist/_worker.js', async () => {
-    await runCloudflareAdapter(root)
-    expect(existsSync(join(root, 'dist/_worker.js'))).toBe(false)
-  })
-
-  it('writes wrangler.toml without nodejs_compat', async () => {
-    await runCloudflareAdapter(root)
-    const toml = readText(root, 'wrangler.toml')
-    expect(toml).not.toContain('nodejs_compat')
-    expect(toml).toContain('dist')
-  })
-})
-
-// ─── P1-4: _worker.js size guard ─────────────────────────────────────────────
-
-describe('runCloudflareAdapter — worker size guard (P1-4)', () => {
-  let root: string
-
-  beforeEach(() => {
-    root = createTempRoot()
-    writeFile(root, 'dist/server/server.js', '// server bundle')
-    writeFile(root, 'dist/client/index.html', '<html><body>shell</body></html>')
-  })
-
-  afterEach(() => rmSync(root, { recursive: true, force: true }))
-
-  it('completes without error when worker is under 900 KB', async () => {
-    // Default small worker — well under limits
-    await expect(runCloudflareAdapter(root)).resolves.not.toThrow()
-  })
-
-  it('warns to console when worker exceeds 900 KB', async () => {
-    // Write a large client HTML to inflate the worker
-    const largePadding = 'x'.repeat(950_000)
-    writeFile(root, 'dist/client/index.html', `<html><body>${largePadding}</body></html>`)
-    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
-    await runCloudflareAdapter(root)
-    expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('KB'))
-    warnSpy.mockRestore()
-  })
-
-  it('exits with error when worker exceeds 9 MB', async () => {
-    const hugePadding = 'x'.repeat(9_100_000)
-    writeFile(root, 'dist/client/index.html', `<html><body>${hugePadding}</body></html>`)
-    const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
-    const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => { throw new Error('process.exit called') }) as never)
-    await expect(runCloudflareAdapter(root)).rejects.toThrow('process.exit called')
-    expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('MB'))
-    errorSpy.mockRestore()
-    exitSpy.mockRestore()
-  })
-})
-
-// ─── SSG mode ────────────────────────────────────────────────────────────────
-
-describe('runCloudflareAdapter — SSG mode', () => {
-  let root: string
-
-  beforeEach(() => {
-    root = createTempRoot()
-    writeFile(root, 'dist/server/server.js', '// server bundle')
-    writeFile(root, 'dist/ssg-manifest.json', '{}')
-    writeFile(root, 'dist/index.html', '<html>root ssg</html>')
-    writeFile(root, 'dist/about/index.html', '<html>about ssg</html>')
-    writeFile(root, 'dist/client/index.html', '<html>shell</html>')
-    writeFile(root, 'dist/client/assets/main-abc.js', '// asset')
-  })
-
-  afterEach(() => rmSync(root, { recursive: true, force: true }))
-
-  it('does NOT write dist/_worker.js', async () => {
-    await runCloudflareAdapter(root)
-    expect(existsSync(join(root, 'dist/_worker.js'))).toBe(false)
-  })
-
-  it('copies assets from dist/client/ to dist/assets/', async () => {
-    await runCloudflareAdapter(root)
-    expect(existsSync(join(root, 'dist/assets/main-abc.js'))).toBe(true)
-  })
-
-  it('wrangler.toml does not include nodejs_compat', async () => {
-    await runCloudflareAdapter(root)
-    const toml = readText(root, 'wrangler.toml')
-    expect(toml).not.toContain('nodejs_compat')
-  })
-})