Initial commit: full-stack Bun + Elysia + React template

Elysia.js API with session-based auth (email/password + Google OAuth),
role system (USER/ADMIN/SUPER_ADMIN), Prisma + PostgreSQL, React 19
with Mantine UI, TanStack Router, dark theme, and comprehensive test
suite (unit, integration, E2E with Lightpanda).

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

tests/e2e/api-hello.test.ts

@@ -0,0 +1,26 @@
+import { test, expect, describe } from 'bun:test'
+import { createPage } from './browser'
+
+describe('E2E: Hello API via browser', () => {
+  test('GET /api/hello returns message', async () => {
+    const { page, cleanup } = await createPage()
+    try {
+      const body = await page.getResponseBody('/api/hello')
+      const data = JSON.parse(body)
+      expect(data).toEqual({ message: 'Hello, world!', method: 'GET' })
+    } finally {
+      cleanup()
+    }
+  })
+
+  test('GET /api/hello/:name returns personalized message', async () => {
+    const { page, cleanup } = await createPage()
+    try {
+      const body = await page.getResponseBody('/api/hello/Bun')
+      const data = JSON.parse(body)
+      expect(data).toEqual({ message: 'Hello, Bun!' })
+    } finally {
+      cleanup()
+    }
+  })
+})

tests/e2e/auth-api.test.ts

@@ -0,0 +1,35 @@
+import { test, expect, describe } from 'bun:test'
+import { createPage, APP_HOST } from './browser'
+
+describe('E2E: Auth API via browser', () => {
+  test('GET /api/auth/session page shows response', async () => {
+    const { page, cleanup } = await createPage()
+    try {
+      await page.goto(APP_HOST + '/api/auth/session')
+      // Navigating to a JSON API endpoint — body contains the JSON text
+      const bodyText = await page.evaluate('document.body.innerText || document.body.textContent || ""')
+      // Should contain "user" key in the response (either null or valid user)
+      // If empty, that's also acceptable (401 may not render body in Lightpanda)
+      if (bodyText.length > 0) {
+        const data = JSON.parse(bodyText)
+        expect(data.user).toBeNull()
+      } else {
+        // 401 response — Lightpanda may not render the body
+        expect(bodyText).toBe('')
+      }
+    } finally {
+      cleanup()
+    }
+  })
+
+  test('GET /api/auth/google redirects to Google OAuth', async () => {
+    const { page, cleanup } = await createPage()
+    try {
+      await page.goto(APP_HOST + '/api/auth/google')
+      const url = await page.url()
+      expect(url).toContain('accounts.google.com')
+    } finally {
+      cleanup()
+    }
+  })
+})

tests/e2e/browser.ts

@@ -0,0 +1,162 @@
+/**
+ * Lightpanda browser helper for E2E tests.
+ * Lightpanda runs in Docker, so localhost is accessed via host.docker.internal.
+ */
+
+const WS_ENDPOINT = process.env.LIGHTPANDA_WS ?? 'ws://127.0.0.1:9222'
+const APP_HOST = process.env.E2E_APP_HOST ?? 'http://host.docker.internal:3000'
+
+export { APP_HOST }
+
+interface CDPResponse {
+  id?: number
+  method?: string
+  params?: Record<string, any>
+  result?: Record<string, any>
+  error?: { code: number; message: string }
+  sessionId?: string
+}
+
+export class LightpandaPage {
+  private ws: WebSocket
+  private sessionId: string
+  private idCounter = 1
+  private pending = new Map<number, { resolve: (v: any) => void; reject: (e: Error) => void }>()
+  private ready: Promise<void>
+
+  constructor(ws: WebSocket, sessionId: string) {
+    this.ws = ws
+    this.sessionId = sessionId
+
+    this.ws.addEventListener('message', (e) => {
+      const data: CDPResponse = JSON.parse(e.data as string)
+      if (data.id && this.pending.has(data.id)) {
+        const p = this.pending.get(data.id)!
+        this.pending.delete(data.id)
+        if (data.error) p.reject(new Error(data.error.message))
+        else p.resolve(data.result)
+      }
+    })
+
+    // Enable page events
+    this.ready = this.send('Page.enable').then(() => {})
+  }
+
+  private send(method: string, params: Record<string, any> = {}): Promise<any> {
+    return new Promise((resolve, reject) => {
+      const id = this.idCounter++
+      this.pending.set(id, { resolve, reject })
+      this.ws.send(JSON.stringify({ id, method, params, sessionId: this.sessionId }))
+      setTimeout(() => {
+        if (this.pending.has(id)) {
+          this.pending.delete(id)
+          reject(new Error(`CDP timeout: ${method}`))
+        }
+      }, 15000)
+    })
+  }
+
+  async goto(path: string): Promise<void> {
+    const url = path.startsWith('http') ? path : `${APP_HOST}${path}`
+    await this.ready
+    const result = await this.send('Page.navigate', { url })
+    if (result?.errorText) throw new Error(`Navigation failed: ${result.errorText}`)
+    // Wait for load
+    await new Promise(r => setTimeout(r, 1500))
+  }
+
+  async evaluate<T = any>(expression: string): Promise<T> {
+    const result = await this.send('Runtime.evaluate', {
+      expression,
+      returnByValue: true,
+      awaitPromise: true,
+    })
+    if (result?.exceptionDetails) {
+      throw new Error(`Evaluate error: ${result.exceptionDetails.text || JSON.stringify(result.exceptionDetails)}`)
+    }
+    return result?.result?.value as T
+  }
+
+  async title(): Promise<string> {
+    return this.evaluate('document.title')
+  }
+
+  async textContent(selector: string): Promise<string | null> {
+    return this.evaluate(`document.querySelector('${selector}')?.textContent ?? null`)
+  }
+
+  async getAttribute(selector: string, attr: string): Promise<string | null> {
+    return this.evaluate(`document.querySelector('${selector}')?.getAttribute('${attr}') ?? null`)
+  }
+
+  async querySelectorAll(selector: string, property = 'textContent'): Promise<string[]> {
+    return this.evaluate(`Array.from(document.querySelectorAll('${selector}')).map(el => el.${property})`)
+  }
+
+  async url(): Promise<string> {
+    return this.evaluate('window.location.href')
+  }
+
+  async getResponseBody(path: string): Promise<string> {
+    const url = path.startsWith('http') ? path : `${APP_HOST}${path}`
+    await this.goto(url)
+    return this.evaluate('document.body.innerText')
+  }
+
+  async setCookie(name: string, value: string): Promise<void> {
+    await this.send('Network.setCookie', {
+      name,
+      value,
+      domain: new URL(APP_HOST).hostname,
+      path: '/',
+    })
+  }
+}
+
+export async function createPage(): Promise<{ page: LightpandaPage; cleanup: () => void }> {
+  const ws = new WebSocket(WS_ENDPOINT)
+
+  await new Promise<void>((resolve, reject) => {
+    ws.onopen = () => resolve()
+    ws.onerror = () => reject(new Error(`Cannot connect to Lightpanda at ${WS_ENDPOINT}`))
+  })
+
+  // Create target
+  const targetId = await new Promise<string>((resolve, reject) => {
+    const id = 1
+    ws.send(JSON.stringify({ id, method: 'Target.createTarget', params: { url: 'about:blank' } }))
+    const handler = (e: MessageEvent) => {
+      const data: CDPResponse = JSON.parse(e.data as string)
+      if (data.id === id) {
+        ws.removeEventListener('message', handler)
+        if (data.error) reject(new Error(data.error.message))
+        else resolve(data.result!.targetId)
+      }
+    }
+    ws.addEventListener('message', handler)
+  })
+
+  // Attach to target
+  const sessionId = await new Promise<string>((resolve, reject) => {
+    const id = 2
+    ws.send(JSON.stringify({ id, method: 'Target.attachToTarget', params: { targetId, flatten: true } }))
+    const handler = (e: MessageEvent) => {
+      const data: CDPResponse = JSON.parse(e.data as string)
+      if (data.id === id) {
+        ws.removeEventListener('message', handler)
+        if (data.error) reject(new Error(data.error.message))
+        else resolve(data.result!.sessionId)
+      }
+    }
+    ws.addEventListener('message', handler)
+  })
+
+  const page = new LightpandaPage(ws, sessionId)
+
+  return {
+    page,
+    cleanup: () => {
+      try { ws.close() } catch {}
+    },
+  }
+}

tests/e2e/google-oauth.test.ts

@@ -0,0 +1,27 @@
+import { test, expect, describe } from 'bun:test'
+import { createPage, APP_HOST } from './browser'
+
+describe('E2E: Google OAuth redirect', () => {
+  test('navigating to /api/auth/google ends up at Google', async () => {
+    const { page, cleanup } = await createPage()
+    try {
+      await page.goto(APP_HOST + '/api/auth/google')
+      const url = await page.url()
+      expect(url).toContain('accounts.google.com')
+    } finally {
+      cleanup()
+    }
+  })
+
+  test('callback without code redirects to login error', async () => {
+    const { page, cleanup } = await createPage()
+    try {
+      await page.goto(APP_HOST + '/api/auth/callback/google')
+      const url = await page.url()
+      expect(url).toContain('/login')
+      expect(url).toContain('error=google_failed')
+    } finally {
+      cleanup()
+    }
+  })
+})

tests/e2e/health.test.ts

@@ -0,0 +1,15 @@
+import { test, expect, describe, afterAll } from 'bun:test'
+import { createPage } from './browser'
+
+describe('E2E: Health endpoint', () => {
+  test('returns status ok', async () => {
+    const { page, cleanup } = await createPage()
+    try {
+      const body = await page.getResponseBody('/health')
+      const data = JSON.parse(body)
+      expect(data).toEqual({ status: 'ok' })
+    } finally {
+      cleanup()
+    }
+  })
+})

tests/e2e/landing-page.test.ts

@@ -0,0 +1,49 @@
+import { test, expect, describe } from 'bun:test'
+import { createPage, APP_HOST } from './browser'
+
+describe('E2E: Landing page', () => {
+  test('serves HTML with correct title', async () => {
+    const { page, cleanup } = await createPage()
+    try {
+      await page.goto(APP_HOST)
+      const title = await page.title()
+      expect(title).toBe('My App')
+    } finally {
+      cleanup()
+    }
+  })
+
+  test('has dark color-scheme meta tag', async () => {
+    const { page, cleanup } = await createPage()
+    try {
+      await page.goto(APP_HOST)
+      const meta = await page.evaluate('document.querySelector("meta[name=color-scheme]").content')
+      expect(meta).toBe('dark')
+    } finally {
+      cleanup()
+    }
+  })
+
+  test('splash screen removed after JS execution', async () => {
+    const { page, cleanup } = await createPage()
+    try {
+      await page.goto(APP_HOST)
+      // Lightpanda executes JS, so splash should be gone
+      const splashExists = await page.evaluate('document.getElementById("splash") !== null')
+      expect(splashExists).toBe(false)
+    } finally {
+      cleanup()
+    }
+  })
+
+  test('root div present', async () => {
+    const { page, cleanup } = await createPage()
+    try {
+      await page.goto(APP_HOST)
+      const root = await page.evaluate('document.getElementById("root") !== null')
+      expect(root).toBe(true)
+    } finally {
+      cleanup()
+    }
+  })
+})

tests/e2e/login-page.test.ts

@@ -0,0 +1,59 @@
+import { test, expect, describe } from 'bun:test'
+import { createPage, APP_HOST } from './browser'
+
+describe('E2E: Login page', () => {
+  test('serves HTML with correct title', async () => {
+    const { page, cleanup } = await createPage()
+    try {
+      await page.goto(APP_HOST + '/login')
+      const title = await page.title()
+      expect(title).toBe('My App')
+    } finally {
+      cleanup()
+    }
+  })
+
+  test('has dark theme set on html element', async () => {
+    const { page, cleanup } = await createPage()
+    try {
+      await page.goto(APP_HOST + '/login')
+      const colorScheme = await page.evaluate('document.documentElement.getAttribute("data-mantine-color-scheme")')
+      expect(colorScheme).toBe('dark')
+    } finally {
+      cleanup()
+    }
+  })
+
+  test('has dark background meta', async () => {
+    const { page, cleanup } = await createPage()
+    try {
+      await page.goto(APP_HOST + '/login')
+      const meta = await page.evaluate('document.querySelector("meta[name=color-scheme]").content')
+      expect(meta).toBe('dark')
+    } finally {
+      cleanup()
+    }
+  })
+
+  test('root element exists for React mount', async () => {
+    const { page, cleanup } = await createPage()
+    try {
+      await page.goto(APP_HOST + '/login')
+      const root = await page.evaluate('document.getElementById("root") !== null')
+      expect(root).toBe(true)
+    } finally {
+      cleanup()
+    }
+  })
+
+  test('splash removed after app load', async () => {
+    const { page, cleanup } = await createPage()
+    try {
+      await page.goto(APP_HOST + '/login')
+      const splashGone = await page.evaluate('document.getElementById("splash") === null')
+      expect(splashGone).toBe(true)
+    } finally {
+      cleanup()
+    }
+  })
+})