@jasonshimmy/vite-plugin-cer-app 0.23.2 → 0.25.0

package/src/__tests__/plugin/virtual/server-api.test.ts

@@ -1,164 +0,0 @@
-import { vi, describe, it, expect, beforeEach } from 'vitest'
-
-vi.mock('node:fs', () => ({ existsSync: vi.fn() }))
-vi.mock('../../../plugin/scanner.js', () => ({ scanDirectory: vi.fn() }))
-
-import { existsSync } from 'node:fs'
-import { scanDirectory } from '../../../plugin/scanner.js'
-import { generateServerApiCode } from '../../../plugin/virtual/server-api.js'
-
-const API = '/project/server/api'
-
-describe('generateServerApiCode', () => {
-  beforeEach(() => {
-    vi.mocked(existsSync).mockReturnValue(true)
-    vi.mocked(scanDirectory).mockResolvedValue([])
-  })
-
-  it('returns empty apiRoutes when directory does not exist', async () => {
-    vi.mocked(existsSync).mockReturnValue(false)
-    const code = await generateServerApiCode(API)
-    expect(code).toMatch(/export const apiRoutes\s*=\s*\[\s*\]/)
-    expect(code).toContain('export default apiRoutes')
-  })
-
-  it('returns empty apiRoutes when no files found', async () => {
-    const code = await generateServerApiCode(API)
-    expect(code).toMatch(/export const apiRoutes\s*=\s*\[\s*\]/)
-  })
-
-  it('includes AUTO-GENERATED comment', async () => {
-    vi.mocked(scanDirectory).mockResolvedValue([`${API}/health.ts`])
-    const code = await generateServerApiCode(API)
-    expect(code).toContain('AUTO-GENERATED by @jasonshimmy/vite-plugin-cer-app')
-  })
-
-  it('prefixes route path with /api/', async () => {
-    vi.mocked(scanDirectory).mockResolvedValue([`${API}/health.ts`])
-    const code = await generateServerApiCode(API)
-    expect(code).toContain('path: "/api/health"')
-  })
-
-  it('maps users/index.ts to /api/users', async () => {
-    vi.mocked(scanDirectory).mockResolvedValue([`${API}/users/index.ts`])
-    const code = await generateServerApiCode(API)
-    expect(code).toContain('path: "/api/users"')
-  })
-
-  it('maps dynamic route [id].ts to /api/users/:id', async () => {
-    vi.mocked(scanDirectory).mockResolvedValue([`${API}/users/[id].ts`])
-    const code = await generateServerApiCode(API)
-    expect(code).toContain('path: "/api/users/:id"')
-  })
-
-  it('imports handlers as namespace (import * as)', async () => {
-    vi.mocked(scanDirectory).mockResolvedValue([`${API}/health.ts`])
-    const code = await generateServerApiCode(API)
-    expect(code).toContain('import * as')
-    expect(code).toContain(`"${API}/health.ts"`)
-  })
-
-  it('assigns handlers to each route entry', async () => {
-    vi.mocked(scanDirectory).mockResolvedValue([`${API}/health.ts`])
-    const code = await generateServerApiCode(API)
-    expect(code).toContain('handlers:')
-  })
-
-  it('generates entries for multiple API routes', async () => {
-    vi.mocked(scanDirectory).mockResolvedValue([
-      `${API}/health.ts`,
-      `${API}/users/index.ts`,
-      `${API}/users/[id].ts`,
-    ])
-    const code = await generateServerApiCode(API)
-    expect(code).toContain('"/api/health"')
-    expect(code).toContain('"/api/users"')
-    expect(code).toContain('"/api/users/:id"')
-  })
-
-  it('exports apiRoutes as both named and default export', async () => {
-    vi.mocked(scanDirectory).mockResolvedValue([`${API}/health.ts`])
-    const code = await generateServerApiCode(API)
-    expect(code).toContain('export const apiRoutes')
-    expect(code).toContain('export default apiRoutes')
-  })
-})
-
-describe('generateServerApiCode — OAuth routes', () => {
-  beforeEach(() => {
-    vi.mocked(existsSync).mockReturnValue(false)
-    vi.mocked(scanDirectory).mockResolvedValue([])
-  })
-
-  const authConfig = {
-    providers: {
-      google: { clientId: 'gid', clientSecret: 'gsecret' },
-    },
-  }
-
-  it('imports OAuth handlers when authConfig has providers', async () => {
-    const code = await generateServerApiCode(API, authConfig)
-    expect(code).toContain("import { handleOAuthInitiate, handleOAuthCallback, handleOAuthLogout } from '@jasonshimmy/vite-plugin-cer-app/oauth'")
-  })
-
-  it('serialises the auth config as _authCfg', async () => {
-    const code = await generateServerApiCode(API, authConfig)
-    expect(code).toContain('const _authCfg =')
-    expect(code).toContain('"clientId":"gid"')
-    expect(code).toContain('"clientSecret":"gsecret"')
-  })
-
-  it('prepends OAuth initiate route before user routes', async () => {
-    const code = await generateServerApiCode(API, authConfig)
-    expect(code).toContain("path: '/api/auth/:provider'")
-    expect(code).toContain('handleOAuthInitiate')
-  })
-
-  it('prepends OAuth callback route', async () => {
-    const code = await generateServerApiCode(API, authConfig)
-    expect(code).toContain("path: '/api/auth/callback/:provider'")
-    expect(code).toContain('handleOAuthCallback')
-  })
-
-  it('prepends OAuth logout route', async () => {
-    const code = await generateServerApiCode(API, authConfig)
-    expect(code).toContain("path: '/api/auth/logout'")
-    expect(code).toContain('handleOAuthLogout')
-  })
-
-  it('uses redirectAfterLogin from config or defaults to /', async () => {
-    const code = await generateServerApiCode(API, { ...authConfig, redirectAfterLogin: '/dashboard' })
-    expect(code).toContain('"redirectAfterLogin":"/dashboard"')
-  })
-
-  it('defaults redirectAfterLogin and redirectAfterLogout to / when not set', async () => {
-    const code = await generateServerApiCode(API, authConfig)
-    expect(code).toContain('"redirectAfterLogin":"/"')
-    expect(code).toContain('"redirectAfterLogout":"/"')
-  })
-
-  it('uses sessionKey from config or defaults to auth', async () => {
-    const code = await generateServerApiCode(API, authConfig)
-    expect(code).toContain('"sessionKey":"auth"')
-  })
-
-  it('does not add OAuth routes when authConfig is null', async () => {
-    const code = await generateServerApiCode(API, null)
-    expect(code).not.toContain('handleOAuthInitiate')
-    expect(code).not.toContain("'/api/auth/:provider'")
-  })
-
-  it('does not add OAuth routes when providers object is empty', async () => {
-    const code = await generateServerApiCode(API, { providers: {} })
-    expect(code).not.toContain('handleOAuthInitiate')
-  })
-
-  it('OAuth routes appear before user API routes', async () => {
-    vi.mocked(existsSync).mockReturnValue(true)
-    vi.mocked(scanDirectory).mockResolvedValue([`${API}/health.ts`])
-    const code = await generateServerApiCode(API, authConfig)
-    const oauthIdx = code.indexOf("'/api/auth/:provider'")
-    const userIdx = code.indexOf('"/api/health"')
-    expect(oauthIdx).toBeLessThan(userIdx)
-  })
-})

package/src/__tests__/plugin/virtual/server-middleware.test.ts

@@ -1,102 +0,0 @@
-import { vi, describe, it, expect, beforeEach } from 'vitest'
-
-vi.mock('node:fs', () => ({ existsSync: vi.fn() }))
-vi.mock('../../../plugin/scanner.js', () => ({ scanDirectory: vi.fn() }))
-
-import { existsSync } from 'node:fs'
-import { scanDirectory } from '../../../plugin/scanner.js'
-import { generateServerMiddlewareCode } from '../../../plugin/virtual/server-middleware.js'
-
-const MIDDLEWARE_DIR = '/project/server/middleware'
-
-describe('generateServerMiddlewareCode', () => {
-  beforeEach(() => {
-    vi.mocked(existsSync).mockReturnValue(true)
-    vi.mocked(scanDirectory).mockResolvedValue([])
-  })
-
-  it('returns empty serverMiddleware when directory does not exist', async () => {
-    vi.mocked(existsSync).mockReturnValue(false)
-    const code = await generateServerMiddlewareCode(MIDDLEWARE_DIR)
-    expect(code).toContain('export const serverMiddleware = []')
-    expect(code).toContain('export default serverMiddleware')
-  })
-
-  it('returns empty serverMiddleware when no files found', async () => {
-    const code = await generateServerMiddlewareCode(MIDDLEWARE_DIR)
-    expect(code).toContain('export const serverMiddleware = []')
-    expect(code).toContain('export default serverMiddleware')
-  })
-
-  it('includes AUTO-GENERATED comment', async () => {
-    vi.mocked(scanDirectory).mockResolvedValue([`${MIDDLEWARE_DIR}/logger.ts`])
-    const code = await generateServerMiddlewareCode(MIDDLEWARE_DIR)
-    expect(code).toContain('AUTO-GENERATED by @jasonshimmy/vite-plugin-cer-app')
-  })
-
-  it('generates import for a middleware file', async () => {
-    vi.mocked(scanDirectory).mockResolvedValue([`${MIDDLEWARE_DIR}/logger.ts`])
-    const code = await generateServerMiddlewareCode(MIDDLEWARE_DIR)
-    expect(code).toContain(`import _sm_logger from "${MIDDLEWARE_DIR}/logger.ts"`)
-  })
-
-  it('registers middleware with its name and handler', async () => {
-    vi.mocked(scanDirectory).mockResolvedValue([`${MIDDLEWARE_DIR}/logger.ts`])
-    const code = await generateServerMiddlewareCode(MIDDLEWARE_DIR)
-    expect(code).toContain('name: "logger"')
-    expect(code).toContain('handler: _sm_logger?.default ?? _sm_logger')
-  })
-
-  it('exports serverMiddleware as both named and default export', async () => {
-    vi.mocked(scanDirectory).mockResolvedValue([`${MIDDLEWARE_DIR}/logger.ts`])
-    const code = await generateServerMiddlewareCode(MIDDLEWARE_DIR)
-    expect(code).toContain('export const serverMiddleware = [')
-    expect(code).toContain('export default serverMiddleware')
-  })
-
-  it('replaces dashes with underscores in the alias identifier', async () => {
-    vi.mocked(scanDirectory).mockResolvedValue([`${MIDDLEWARE_DIR}/check-auth.ts`])
-    const code = await generateServerMiddlewareCode(MIDDLEWARE_DIR)
-    expect(code).toContain('_sm_check_auth')
-    expect(code).toContain('name: "check-auth"')
-  })
-
-  it('prepends underscore to identifiers starting with a digit', async () => {
-    vi.mocked(scanDirectory).mockResolvedValue([`${MIDDLEWARE_DIR}/1first.ts`])
-    const code = await generateServerMiddlewareCode(MIDDLEWARE_DIR)
-    expect(code).toContain('_sm__1first')
-  })
-
-  it('handles multiple middleware files', async () => {
-    vi.mocked(scanDirectory).mockResolvedValue([
-      `${MIDDLEWARE_DIR}/logger.ts`,
-      `${MIDDLEWARE_DIR}/auth.ts`,
-    ])
-    const code = await generateServerMiddlewareCode(MIDDLEWARE_DIR)
-    expect(code).toContain('name: "auth"')
-    expect(code).toContain('name: "logger"')
-  })
-
-  it('sorts middleware files alphabetically', async () => {
-    vi.mocked(scanDirectory).mockResolvedValue([
-      `${MIDDLEWARE_DIR}/zz-last.ts`,
-      `${MIDDLEWARE_DIR}/aa-first.ts`,
-    ])
-    const code = await generateServerMiddlewareCode(MIDDLEWARE_DIR)
-    const authIdx = code.indexOf('aa-first')
-    const loggerIdx = code.indexOf('zz-last')
-    expect(authIdx).toBeLessThan(loggerIdx)
-  })
-
-  it('ends with a newline', async () => {
-    vi.mocked(scanDirectory).mockResolvedValue([`${MIDDLEWARE_DIR}/logger.ts`])
-    const code = await generateServerMiddlewareCode(MIDDLEWARE_DIR)
-    expect(code.endsWith('\n')).toBe(true)
-  })
-
-  it('returns AUTO-GENERATED comment even when directory is missing', async () => {
-    vi.mocked(existsSync).mockReturnValue(false)
-    const code = await generateServerMiddlewareCode(MIDDLEWARE_DIR)
-    expect(code).toContain('AUTO-GENERATED by @jasonshimmy/vite-plugin-cer-app')
-  })
-})

package/src/__tests__/runtime/app-template.test.ts

@@ -1,208 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { generateAppEntryTemplate } from '../../runtime/app-template.js'
-
-const APP_ENTRY_TEMPLATE = generateAppEntryTemplate()
-
-// ─── Hydration strategy ───────────────────────────────────────────────────────
-
-describe('APP_ENTRY_TEMPLATE — meta.hydrate', () => {
-  it('reads meta.hydrate from the matched route', () => {
-    expect(APP_ENTRY_TEMPLATE).toContain('_initMatch?.route?.meta?.hydrate')
-  })
-
-  it('defaults to "load" when hydrate is not set', () => {
-    expect(APP_ENTRY_TEMPLATE).toContain(`?? 'load'`)
-  })
-
-  it('skips hydration entirely for strategy "none"', () => {
-    expect(APP_ENTRY_TEMPLATE).toContain(`_hydrateStrategy === 'none'`)
-    // Should delete __CER_DATA__ but NOT call _replace
-    const noneBlock = APP_ENTRY_TEMPLATE.slice(
-      APP_ENTRY_TEMPLATE.indexOf(`_hydrateStrategy === 'none'`),
-    )
-    // The delete must appear before _doHydrate is defined (i.e. in the none branch)
-    expect(APP_ENTRY_TEMPLATE).toContain(`delete (globalThis).__CER_DATA__`)
-  })
-
-  it('defers hydration with requestIdleCallback for strategy "idle"', () => {
-    expect(APP_ENTRY_TEMPLATE).toContain(`_hydrateStrategy === 'idle'`)
-    expect(APP_ENTRY_TEMPLATE).toContain('requestIdleCallback')
-  })
-
-  it('includes a setTimeout fallback for environments without requestIdleCallback', () => {
-    expect(APP_ENTRY_TEMPLATE).toContain('typeof requestIdleCallback')
-    expect(APP_ENTRY_TEMPLATE).toContain('setTimeout')
-  })
-
-  it('defers hydration with IntersectionObserver for strategy "visible"', () => {
-    expect(APP_ENTRY_TEMPLATE).toContain(`_hydrateStrategy === 'visible'`)
-    expect(APP_ENTRY_TEMPLATE).toContain('IntersectionObserver')
-  })
-
-  it('observes cer-layout-view element for "visible" strategy', () => {
-    expect(APP_ENTRY_TEMPLATE).toContain(`querySelector('cer-layout-view')`)
-  })
-
-  it('falls back to document.body when cer-layout-view is not found', () => {
-    expect(APP_ENTRY_TEMPLATE).toContain('document.body')
-  })
-
-  it('disconnects the IntersectionObserver after first intersection', () => {
-    expect(APP_ENTRY_TEMPLATE).toContain('_io.disconnect()')
-  })
-
-  it('calls _doHydrate immediately for strategy "load"', () => {
-    // The else branch (default load) calls _doHydrate directly with await
-    expect(APP_ENTRY_TEMPLATE).toContain('await _doHydrate()')
-  })
-
-  it('_doHydrate pre-loads the page and calls _replace', () => {
-    expect(APP_ENTRY_TEMPLATE).toContain('await _loadPageForPath(')
-    expect(APP_ENTRY_TEMPLATE).toContain('_initPath,')
-    expect(APP_ENTRY_TEMPLATE).toContain('await _replace(_initPath)')
-  })
-
-  it('_doHydrate reuses existing SSR loader data instead of re-running the initial loader', () => {
-    expect(APP_ENTRY_TEMPLATE).toContain("Object.prototype.hasOwnProperty.call(globalThis, '__CER_DATA__')")
-    expect(APP_ENTRY_TEMPLATE).toContain('runLoader: false')
-    expect(APP_ENTRY_TEMPLATE).toContain('initialData: (globalThis).__CER_DATA__')
-  })
-
-  it('_doHydrate skips _replace if URL changed during async module load', () => {
-    // Guard: only call _replace when the URL hasn't changed during _loadPageForPath.
-    // This prevents _doHydrate from overriding a navigation that fired while the
-    // initial page module was being loaded asynchronously.
-    const doHydrateStart = APP_ENTRY_TEMPLATE.indexOf('const _doHydrate')
-    const doHydrateEnd = APP_ENTRY_TEMPLATE.indexOf('\n    }', doHydrateStart)
-    const doHydrateBlock = APP_ENTRY_TEMPLATE.slice(doHydrateStart, doHydrateEnd)
-    expect(doHydrateBlock).toContain('_currentPath === _initPath')
-    expect(doHydrateBlock).toContain('window.location.pathname')
-  })
-
-  it('guards direct page render with _currentPagePath === current.value.path', () => {
-    expect(APP_ENTRY_TEMPLATE).toContain('_currentPagePath')
-    expect(APP_ENTRY_TEMPLATE).toContain('_currentPagePath === current.value.path')
-  })
-
-  it('keeps the SSR slot during the router subscribe initial state push', () => {
-    expect(APP_ENTRY_TEMPLATE).toContain('let _sawInitialRouteState = false')
-    expect(APP_ENTRY_TEMPLATE).toContain('const _isInitialSubscribePush = !_sawInitialRouteState')
-    expect(APP_ENTRY_TEMPLATE).toContain('if (_isInitialSubscribePush) {')
-    expect(APP_ENTRY_TEMPLATE).toContain('return')
-  })
-
-  it('keeps the SSR slot during the initRouter startup microtask navigation (before page chunk loads)', () => {
-    // initRouter() queues queueMicrotask(() => navigate(...)) to run guards on
-    // the entry URL. That microtask fires during await route.load() — before
-    // _currentPageTag is set. Without this guard, _cerHydrating would be set to
-    // false prematurely, dropping the SSR slot and showing an empty router-view.
-    expect(APP_ENTRY_TEMPLATE).toContain(
-      'if (_cerHydrating.value && _currentPageTag !== null) _cerHydrating.value = false',
-    )
-  })
-
-  it('exposes router globally as __cerRouter', () => {
-    expect(APP_ENTRY_TEMPLATE).toContain('__cerRouter')
-  })
-
-  it('_doHydrate keeps initial __CER_DATA__ available after hydration', () => {
-    // The initial page data must survive hydration because some browsers may
-    // perform a later upgrade/re-render of the hydrated page component. The
-    // next real client navigation clears __CER_DATA__ before loading new data.
-    const doHydrateStart = APP_ENTRY_TEMPLATE.indexOf('const _doHydrate')
-    const doHydrateEnd = APP_ENTRY_TEMPLATE.indexOf('\n    }', doHydrateStart)
-    const doHydrateBlock = APP_ENTRY_TEMPLATE.slice(doHydrateStart, doHydrateEnd)
-    expect(doHydrateBlock).not.toContain('queueMicrotask(() => { delete (globalThis).__CER_DATA__ })')
-  })
-})
-
-// ─── Loader sequence ──────────────────────────────────────────────────────────
-
-describe('APP_ENTRY_TEMPLATE — loader sequence', () => {
-  it('_loadPageForPath calls mod.loader with { params, query }', () => {
-    expect(APP_ENTRY_TEMPLATE).toContain('mod.loader({ params, query })')
-  })
-
-  it('_loadPageForPath sets globalThis.__CER_DATA__ from loader result', () => {
-    expect(APP_ENTRY_TEMPLATE).toContain('(globalThis).__CER_DATA__ = data')
-  })
-
-  it('_loadPageForPath derives primitive attrs from reused loader data too', () => {
-    expect(APP_ENTRY_TEMPLATE).toContain('function _toLoaderAttrs(data)')
-    expect(APP_ENTRY_TEMPLATE).toContain('loaderAttrs = { ...loaderAttrs, ..._toLoaderAttrs(loaderData) }')
-  })
-
-  it('_loadPageForPath merges loader primitive values into _currentPageAttrs', () => {
-    expect(APP_ENTRY_TEMPLATE).toContain('_currentPageAttrs = loaderAttrs')
-  })
-
-  it('_currentPageAttrs is passed as attrs in the direct-render page vnode', () => {
-    // The direct-render path passes _currentPageAttrs to the page element attrs
-    // so useProps() in the page component can read loader-returned primitives.
-    expect(APP_ENTRY_TEMPLATE).toContain('attrs: _currentPageAttrs')
-  })
-
-  it('router.push deletes __CER_DATA__ before loading the new page', () => {
-    // Prevents stale loader data from leaking to pages without a loader.
-    const pushStart = APP_ENTRY_TEMPLATE.indexOf('router.push = async')
-    const pushEnd = APP_ENTRY_TEMPLATE.indexOf('\n}', pushStart)
-    const pushBlock = APP_ENTRY_TEMPLATE.slice(pushStart, pushEnd)
-    expect(pushBlock).toContain('delete (globalThis).__CER_DATA__')
-    // The delete must appear before _loadPageForPath is called.
-    const deleteIdx = pushBlock.indexOf('delete (globalThis).__CER_DATA__')
-    const loadIdx = pushBlock.indexOf('_loadPageForPath')
-    expect(deleteIdx).toBeLessThan(loadIdx)
-  })
-
-  it('router.replace deletes __CER_DATA__ before loading the new page', () => {
-    const replaceStart = APP_ENTRY_TEMPLATE.indexOf('router.replace = async')
-    const replaceEnd = APP_ENTRY_TEMPLATE.indexOf('\n}', replaceStart)
-    const replaceBlock = APP_ENTRY_TEMPLATE.slice(replaceStart, replaceEnd)
-    expect(replaceBlock).toContain('delete (globalThis).__CER_DATA__')
-    const deleteIdx = replaceBlock.indexOf('delete (globalThis).__CER_DATA__')
-    const loadIdx = replaceBlock.indexOf('_loadPageForPath')
-    expect(deleteIdx).toBeLessThan(loadIdx)
-  })
-
-  it('router.push awaits _loadPageForPath before _push', () => {
-    const pushStart = APP_ENTRY_TEMPLATE.indexOf('router.push = async')
-    const pushEnd = APP_ENTRY_TEMPLATE.indexOf('\n}', pushStart)
-    const pushBlock = APP_ENTRY_TEMPLATE.slice(pushStart, pushEnd)
-    const loadIdx = pushBlock.indexOf('await _loadPageForPath')
-    const pushIdx = pushBlock.indexOf('await _push')
-    expect(loadIdx).toBeGreaterThanOrEqual(0)
-    expect(pushIdx).toBeGreaterThan(loadIdx)
-  })
-
-  it('router.replace awaits _loadPageForPath before _replace', () => {
-    const replaceStart = APP_ENTRY_TEMPLATE.indexOf('router.replace = async')
-    const replaceEnd = APP_ENTRY_TEMPLATE.indexOf('\n}', replaceStart)
-    const replaceBlock = APP_ENTRY_TEMPLATE.slice(replaceStart, replaceEnd)
-    const loadIdx = replaceBlock.indexOf('await _loadPageForPath')
-    const replaceIdx = replaceBlock.indexOf('await _replace')
-    expect(loadIdx).toBeGreaterThanOrEqual(0)
-    expect(replaceIdx).toBeGreaterThan(loadIdx)
-  })
-
-  it('surfaces loader errors to currentError so the error boundary is shown', () => {
-    // The catch block must set currentError.value instead of silently swallowing errors.
-    // This is consistent with how the server-side handler renders the error component.
-    const loadPageStart = APP_ENTRY_TEMPLATE.indexOf('async function _loadPageForPath')
-    const loadPageEnd = APP_ENTRY_TEMPLATE.indexOf('\n}', loadPageStart)
-    const loadPageBlock = APP_ENTRY_TEMPLATE.slice(loadPageStart, loadPageEnd)
-    expect(loadPageBlock).toContain('currentError.value =')
-    // Must not silently swallow — the old pattern was `catch { /* ... */ }`
-    expect(loadPageBlock).not.toContain('/* loader errors are non-fatal')
-  })
-
-  it('uses per-route errorTag over global errorTag in cer-layout-view error rendering', () => {
-    // routeMeta must be computed before the currentError check so the per-route
-    // error component can be selected (mirrors server-side _prepareRequest logic).
-    const template = APP_ENTRY_TEMPLATE
-    expect(template).toContain('routeMeta?.errorTag')
-    // Falls back to global errorTag when no per-route error component exists
-    expect(template).toContain('hasError ? errorTag : null')
-    // The effectiveErrorTag variable is used as the rendered tag
-    expect(template).toContain('effectiveErrorTag')
-  })
-})

package/src/__tests__/runtime/define-middleware.test.ts

@@ -1,64 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { defineMiddleware } from '../../runtime/composables/define-middleware.js'
-import type { MiddlewareFn } from '../../types/middleware.js'
-
-describe('defineMiddleware', () => {
-  it('returns the function passed to it unchanged', () => {
-    const fn: MiddlewareFn = async () => true
-    expect(defineMiddleware(fn)).toBe(fn)
-  })
-
-  it('the returned function returns true to allow navigation', async () => {
-    const mw = defineMiddleware(async () => true)
-    const result = await mw({} as never, null)
-    expect(result).toBe(true)
-  })
-
-  it('the returned function returns false to block navigation', async () => {
-    const mw = defineMiddleware(async () => false)
-    const result = await mw({} as never, null)
-    expect(result).toBe(false)
-  })
-
-  it('the returned function returns a string to redirect', async () => {
-    const mw = defineMiddleware(async () => '/login')
-    const result = await mw({} as never, null)
-    expect(result).toBe('/login')
-  })
-
-  it('the returned function receives to and from route states', async () => {
-    let capturedTo: unknown
-    let capturedFrom: unknown
-    const mw = defineMiddleware((to, from) => {
-      capturedTo = to
-      capturedFrom = from
-      return true
-    })
-    const to = { path: '/dashboard', params: {}, query: {} }
-    const from = { path: '/login', params: {}, query: {} }
-    await mw(to as never, from as never, async () => {})
-    expect(capturedTo).toBe(to)
-    expect(capturedFrom).toBe(from)
-  })
-
-  it('the returned function receives a next() callback as the third argument', async () => {
-    let nextCalled = false
-    const mw = defineMiddleware(async (_to, _from, next) => {
-      await next()
-      nextCalled = true
-    })
-    await mw({} as never, null, async () => { nextCalled = false /* reset before wrapper code runs */ })
-    expect(nextCalled).toBe(true)
-  })
-
-  it('wrapper middleware can run code before and after next()', async () => {
-    const order: string[] = []
-    const mw = defineMiddleware(async (_to, _from, next) => {
-      order.push('before')
-      await next()
-      order.push('after')
-    })
-    await mw({} as never, null, async () => { order.push('next') })
-    expect(order).toEqual(['before', 'next', 'after'])
-  })
-})

package/src/__tests__/runtime/define-server-middleware.test.ts

@@ -1,54 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { defineServerMiddleware } from '../../runtime/composables/define-server-middleware.js'
-import type { ServerMiddleware } from '../../types/middleware.js'
-
-describe('defineServerMiddleware', () => {
-  it('returns the function passed to it unchanged', () => {
-    const fn: ServerMiddleware = async (_req, _res, next) => next()
-    expect(defineServerMiddleware(fn)).toBe(fn)
-  })
-
-  it('the returned function calls next() to continue the chain', async () => {
-    let nextCalled = false
-    const mw = defineServerMiddleware(async (_req, _res, next) => {
-      nextCalled = true
-      next()
-    })
-    await mw({} as never, {} as never, () => {})
-    expect(nextCalled).toBe(true)
-  })
-
-  it('the returned function can end the request without calling next()', async () => {
-    let nextCalled = false
-    const mw = defineServerMiddleware(async (_req, res: { end: (b: string) => void }, _next) => {
-      res.end('Unauthorized')
-    })
-    await mw({} as never, { end: () => { nextCalled = false } } as never, () => { nextCalled = true })
-    expect(nextCalled).toBe(false)
-  })
-
-  it('receives req, res, and next as arguments', async () => {
-    let capturedReq: unknown
-    let capturedRes: unknown
-    let capturedNext: unknown
-    const mw = defineServerMiddleware((req, res, next) => {
-      capturedReq = req
-      capturedRes = res
-      capturedNext = next
-      next()
-    })
-    const fakeReq = { url: '/test' }
-    const fakeRes = { statusCode: 200 }
-    const fakeNext = () => {}
-    await mw(fakeReq as never, fakeRes as never, fakeNext)
-    expect(capturedReq).toBe(fakeReq)
-    expect(capturedRes).toBe(fakeRes)
-    expect(capturedNext).toBe(fakeNext)
-  })
-
-  it('is generic — a typed ServerMiddleware satisfies the return type', () => {
-    const fn: ServerMiddleware = (_req, _res, next) => next()
-    const result = defineServerMiddleware(fn)
-    expect(typeof result).toBe('function')
-  })
-})

package/src/__tests__/runtime/entry-client-template.test.ts

@@ -1,61 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { ENTRY_CLIENT_TEMPLATE } from '../../runtime/entry-client-template.js'
-
-describe('ENTRY_CLIENT_TEMPLATE', () => {
-  it('is exported as a string', () => {
-    expect(typeof ENTRY_CLIENT_TEMPLATE).toBe('string')
-    expect(ENTRY_CLIENT_TEMPLATE.length).toBeGreaterThan(0)
-  })
-
-  it('marks the SSR entry URL before app boots so generated middleware can skip hydration replay once', () => {
-    expect(ENTRY_CLIENT_TEMPLATE).toContain('(globalThis).__CER_HYDRATION_ENTRY__')
-    expect(ENTRY_CLIENT_TEMPLATE).toContain('path: window.location.pathname')
-    expect(ENTRY_CLIENT_TEMPLATE).toContain('new URLSearchParams(window.location.search)')
-  })
-
-  it('captures __CER_DATA__ from window to globalThis before app boots', () => {
-    // SSR loader data must be captured before any module clears window.__CER_DATA__
-    expect(ENTRY_CLIENT_TEMPLATE).toContain('window.__CER_DATA__')
-    expect(ENTRY_CLIENT_TEMPLATE).toContain('(globalThis).__CER_DATA__')
-  })
-
-  it('captures __CER_FETCH_DATA__ from window to globalThis before app boots', () => {
-    // useFetch() hydration data injected by the server must be captured early
-    expect(ENTRY_CLIENT_TEMPLATE).toContain('window.__CER_FETCH_DATA__')
-    expect(ENTRY_CLIENT_TEMPLATE).toContain('(globalThis).__CER_FETCH_DATA__')
-  })
-
-  it('captures __CER_AUTH_USER__ from window to globalThis before app boots', () => {
-    // useAuth() reads the authenticated user from globalThis on the client
-    expect(ENTRY_CLIENT_TEMPLATE).toContain('window.__CER_AUTH_USER__')
-    expect(ENTRY_CLIENT_TEMPLATE).toContain('(globalThis).__CER_AUTH_USER__')
-  })
-
-  it('imports app.js as the framework entry point', () => {
-    expect(ENTRY_CLIENT_TEMPLATE).toContain("import './app.js'")
-  })
-
-  it('guards each capture with a typeof window check', () => {
-    // Guards are required so the template works in SSR environments where
-    // window is not defined.
-    const windowChecks = (ENTRY_CLIENT_TEMPLATE.match(/typeof window !== 'undefined'/g) ?? []).length
-    expect(windowChecks).toBeGreaterThanOrEqual(4)
-  })
-
-  it('captures globals before importing app.js', () => {
-    // The capture blocks must appear BEFORE the app import so that
-    // usePageData() / useFetch() / useAuth() can read them synchronously
-    // during module evaluation.
-    const appImportIdx = ENTRY_CLIENT_TEMPLATE.indexOf("import './app.js'")
-    const cerDataIdx = ENTRY_CLIENT_TEMPLATE.indexOf('window.__CER_DATA__')
-    const fetchDataIdx = ENTRY_CLIENT_TEMPLATE.indexOf('window.__CER_FETCH_DATA__')
-    const authUserIdx = ENTRY_CLIENT_TEMPLATE.indexOf('window.__CER_AUTH_USER__')
-
-    expect(cerDataIdx).toBeGreaterThanOrEqual(0)
-    expect(fetchDataIdx).toBeGreaterThanOrEqual(0)
-    expect(authUserIdx).toBeGreaterThanOrEqual(0)
-    expect(cerDataIdx).toBeLessThan(appImportIdx)
-    expect(fetchDataIdx).toBeLessThan(appImportIdx)
-    expect(authUserIdx).toBeLessThan(appImportIdx)
-  })
-})