create-fullstack-scaffold 0.4.25 → 0.5.1

package/template/src/server/__tests__/integration/todos-api.test.ts

@@ -28,9 +28,12 @@ describe('Integration: Todos API (Real Database)', () => {
     it('should handle complete todo lifecycle', async () => {
       const client = createTestClient(undefined, { headers: authHeaders })
 
-      const listRes = await client.api.todos.$get({ headers: authHeaders })
+      const listRes = await client.api.todos.$get({ query: {} })
       const listData = await listRes.json()
-      expect(listData).toMatchObject({ success: true, data: [] })
+      expect(listData).toMatchObject({
+        success: true,
+        data: { todos: [], total: 0, page: 1, limit: 20 },
+      })
 
       const createRes = await client.api.todos.$post(
         {
@@ -102,10 +105,10 @@ describe('Integration: Todos API (Real Database)', () => {
         expect(res.status).toBe(201)
       })
 
-      const listRes = await client.api.todos.$get({ headers: authHeaders })
+      const listRes = await client.api.todos.$get({ query: {} })
       const listData = await listRes.json()
       if (listData.success && 'data' in listData) {
-        expect(listData.data).toHaveLength(10)
+        expect(listData.data.todos).toHaveLength(10)
       }
     })
   })

package/template/src/server/app.ts

@@ -42,7 +42,11 @@ export function createApp<T extends AppBindings = AppBindings>(_options: CreateA
         return c.json({ status: 'ok', timestamp: new Date().toISOString(), db: 'not configured' })
       }
     })
-    .post('/api/__test__/cleanup', async c => {
+
+  // 测试辅助端点：仅开发/测试环境注册。生产（含 Cloudflare 构建——tsup 将
+  // process.env.NODE_ENV 静态替换为 "production"）不暴露这个清库端点。
+  if (process.env.NODE_ENV !== 'production') {
+    app.post('/api/__test__/cleanup', async c => {
       try {
         const { cleanupTestDatabase } = await import('./db/test-setup')
         await cleanupTestDatabase()
@@ -52,6 +56,7 @@ export function createApp<T extends AppBindings = AppBindings>(_options: CreateA
         return c.json({ success: false as const, message: 'Failed to cleanup database' }, 500)
       }
     })
+  }
 
   autoRegisterRealtime(app as unknown as Parameters<typeof autoRegisterRealtime>[0])
 
@@ -100,6 +105,3 @@ export function createApp<T extends AppBindings = AppBindings>(_options: CreateA
 
   return app
 }
-export type AdminApiType = typeof adminApiRoutes
-export type ClientApiType = typeof clientApiRoutes
-export type AppType = ReturnType<typeof createApp>

package/template/src/server/core/__tests__/isr-cache-cf.test.ts

@@ -0,0 +1,96 @@
+/**
+ * @framework-baseline 4fce8de3d919d2fb
+
+ * CloudflareCacheStore 单测：索引清单（manifest）驱动的 purgePattern。
+ *
+ * 背景：Cache API 没有 list()，purgePattern 曾是恒不执行的死代码——
+ * CF 生产上内容更新后陈旧详情页服务到自然过期。现实现用 isr:__index__
+ * 键记录已缓存 pathname，pattern 据此真清剿。此文件验证该行为。
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest'
+
+/** 极简 Cache API mock：Map<urlString, Response> */
+function makeFakeCaches() {
+  const store = new Map<string, Response>()
+  const cache = {
+    async match(req: Request | string) {
+      const key = typeof req === 'string' ? req : req.url
+      return store.get(key) ?? undefined
+    },
+    async put(req: Request | string, res: Response) {
+      const key = typeof req === 'string' ? req : req.url
+      store.set(key, res)
+    },
+    async delete(req: Request | string) {
+      const key = typeof req === 'string' ? req : req.url
+      return store.delete(key)
+    },
+  }
+  return { caches: { open: async () => cache }, store }
+}
+
+describe('CloudflareCacheStore purgePattern (manifest)', () => {
+  let fake: ReturnType<typeof makeFakeCaches>
+  let originalCaches: unknown
+
+  beforeEach(async () => {
+    fake = makeFakeCaches()
+    originalCaches = (globalThis as { caches?: unknown }).caches
+    ;(globalThis as { caches?: unknown }).caches = fake.caches as never
+    const mod = await import('@server/core/isr-cache')
+    // 重新构造以绑定 mock caches
+    const { createISRCache } = mod
+    const cache = createISRCache({ maxAge: 60, staleWhileRevalidate: 60 })
+    ;(globalThis as Record<string, unknown>).__testCache = cache
+  })
+
+  afterEach(() => {
+    ;(globalThis as { caches?: unknown }).caches = originalCaches as never
+  })
+
+  function getCache() {
+    return (globalThis as Record<string, unknown>).__testCache as {
+      store: (key: string, html: string) => Promise<void>
+      purgePattern: (pattern: string) => Promise<void>
+      lookup: (pathname: string) => Promise<{ status: string }>
+    }
+  }
+
+  it('purgePattern 清剿匹配键并保留其余（索引驱动，非死代码）', async () => {
+    const c = getCache()
+    await c.store('/', 'home')
+    await c.store('/content', 'list')
+    await c.store('/content/123', 'detail-123')
+    await c.store('/content/456', 'detail-456')
+    await c.store('/todos', 'todos')
+
+    await c.purgePattern('isr:/content/*')
+
+    expect((await c.lookup('/content/123')).status).toBe('miss')
+    expect((await c.lookup('/content/456')).status).toBe('miss')
+    // 列表页本身不匹配 isr:/content/*（无尾斜杠通配不到裸键）
+    expect((await c.lookup('/todos')).status).toBe('fresh')
+  })
+
+  it('正则元字符键名不误伤（escapeForPattern）', async () => {
+    const c = getCache()
+    await c.store('/content/1+2', 'plus')
+    await c.store('/content/abc', 'plain')
+
+    // '1+2' 中的 + 若未转义会被当量词，误匹配 '12' 等——这里验证只清目标
+    await c.purgePattern('isr:/content/1+2')
+
+    expect((await c.lookup('/content/1+2')).status).toBe('miss')
+    expect((await c.lookup('/content/abc')).status).toBe('fresh')
+  })
+
+  it('purge 单键后索引同步收缩，后续 purgePattern 不再删幽灵键', async () => {
+    const c = getCache()
+    await c.store('/a', 'a')
+    await c.store('/b', 'b')
+    await c.purgePattern('isr:/a')
+    // 无异常即通过（索引写回路径被走到）
+    expect((await c.lookup('/b')).status).toBe('fresh')
+  })
+})

package/template/src/server/core/__tests__/isr-cache.test.ts

@@ -1,117 +1,121 @@
 /**
- * @framework-baseline dd5cd4fe46320b03
- * @framework-modify
- * @reason 移除未使用的 vi import，修复 TypeScript strict 检查
- * @impact 不影响功能，仅清理代码
+ * @framework-baseline 68a6e13bffb67f13
  */
 
 import { describe, it, expect, beforeEach } from 'vitest'
-import { isISRRoute, generateCacheKey, createISRCache, type ISRCache } from '@server/core/isr-cache'
-
-describe('isISRRoute', () => {
-  it('matches static ISR routes', () => {
-    expect(isISRRoute('/')).toBe(true)
-    expect(isISRRoute('/todos')).toBe(true)
-    expect(isISRRoute('/content')).toBe(true)
-    expect(isISRRoute('/notifications')).toBe(true)
-    expect(isISRRoute('/websocket')).toBe(true)
-  })
-
-  it('matches dynamic content routes', () => {
-    expect(isISRRoute('/content/123')).toBe(true)
-    expect(isISRRoute('/content/content-456')).toBe(true)
-    expect(isISRRoute('/content/abc-def')).toBe(true)
-  })
-
-  it('does not match non-ISR routes', () => {
-    expect(isISRRoute('/api/todos')).toBe(false)
-    expect(isISRRoute('/api/health')).toBe(false)
-    expect(isISRRoute('/assets/main.js')).toBe(false)
-    expect(isISRRoute('/admin/dashboard')).toBe(false)
-    expect(isISRRoute('/health')).toBe(false)
-    expect(isISRRoute('/vite.svg')).toBe(false)
-  })
-})
-
-describe('generateCacheKey', () => {
-  it('normalizes root path', () => {
-    expect(generateCacheKey('/')).toBe('isr:/index')
-  })
-
-  it('generates keys for regular paths', () => {
-    expect(generateCacheKey('/todos')).toBe('isr:/todos')
-    expect(generateCacheKey('/content/123')).toBe('isr:/content/123')
-  })
+import { createISRCache } from '@server/core/isr-cache'
 
-  it('removes trailing slash', () => {
-    expect(generateCacheKey('/todos/')).toBe('isr:/todos')
-  })
-})
-
-describe('ISRCache (memory)', () => {
-  let cache: ISRCache
+describe('ISR Cache', () => {
+  let cache: ReturnType<typeof createISRCache>
 
   beforeEach(() => {
-    cache = createISRCache({ maxAge: 1, staleWhileRevalidate: 1 })
+    cache = createISRCache({ maxAge: 1, staleWhileRevalidate: 2 })
   })
 
-  it('returns miss for uncached routes', async () => {
-    const result = await cache.lookup('/todos')
-    expect(result.status).toBe('miss')
-    expect(result.html).toBeNull()
+  describe('lookup — no cache', () => {
+    it('should return miss for uncached path', async () => {
+      const result = await cache.lookup('/todos')
+      expect(result.status).toBe('miss')
+      expect(result.html).toBeNull()
+    })
   })
 
-  it('stores and retrieves pages', async () => {
-    await cache.store('/todos', '<html>todos</html>')
-    const result = await cache.lookup('/todos')
-    expect(result.status).toBe('fresh')
-    expect(result.html).toBe('<html>todos</html>')
+  describe('store → lookup fresh', () => {
+    it('should return fresh after store', async () => {
+      await cache.store('/todos', '<html>todos</html>')
+      const result = await cache.lookup('/todos')
+      expect(result.status).toBe('fresh')
+      expect(result.html).toBe('<html>todos</html>')
+    })
   })
 
-  it('serves stale content after maxAge', async () => {
-    cache = createISRCache({ maxAge: 0, staleWhileRevalidate: 60 })
-
-    await cache.store('/todos', '<html>todos</html>')
-
-    await new Promise(resolve => setTimeout(resolve, 10))
+  describe('store → wait → lookup stale', () => {
+    it('should return stale after maxAge', async () => {
+      await cache.store('/todos', '<html>todos</html>')
+      // Wait beyond maxAge (1s) but within staleWhileRevalidate (1+2=3s)
+      await new Promise(r => setTimeout(r, 1200))
+      const result = await cache.lookup('/todos')
+      expect(result.status).toBe('stale')
+      expect(result.html).toBe('<html>todos</html>')
+    })
+  })
 
-    const result = await cache.lookup('/todos')
-    expect(result.status).toBe('stale')
-    expect(result.html).toBe('<html>todos</html>')
+  describe('store → wait → lookup miss (expired)', () => {
+    it('should return miss after maxAge + staleWhileRevalidate', async () => {
+      await cache.store('/todos', '<html>todos</html>')
+      // Wait beyond both maxAge and staleWhileRevalidate
+      await new Promise(r => setTimeout(r, 3500))
+      const result = await cache.lookup('/todos')
+      expect(result.status).toBe('miss')
+      expect(result.html).toBeNull()
+    })
   })
 
-  it('returns miss after maxAge + staleWhileRevalidate', async () => {
-    cache = createISRCache({ maxAge: 0, staleWhileRevalidate: 0 })
+  describe('purge', () => {
+    it('should purge specific path', async () => {
+      await cache.store('/todos', '<html>todos</html>')
+      await cache.store('/content', '<html>content</html>')
 
-    await cache.store('/todos', '<html>todos</html>')
+      await cache.purge('/todos')
 
-    await new Promise(resolve => setTimeout(resolve, 10))
+      expect((await cache.lookup('/todos')).status).toBe('miss')
+      expect((await cache.lookup('/content')).status).toBe('fresh')
+    })
 
-    const result = await cache.lookup('/todos')
-    expect(result.status).toBe('miss')
+    it('should not error on purge of uncached path', async () => {
+      await expect(cache.purge('/never-cached')).resolves.not.toThrow()
+    })
   })
 
-  it('purges specific pages', async () => {
-    await cache.store('/todos', '<html>todos</html>')
-    await cache.store('/content', '<html>content</html>')
-
-    await cache.purge('/todos')
-
-    expect((await cache.lookup('/todos')).status).toBe('miss')
-    expect((await cache.lookup('/content')).status).toBe('fresh')
+  describe('purgePattern', () => {
+    it('should purge matching pattern', async () => {
+      await cache.store('/content', '<html>list</html>')
+      await cache.store('/content/article-1', '<html>a1</html>')
+      await cache.store('/content/article-2', '<html>a2</html>')
+      await cache.store('/todos', '<html>todos</html>')
+
+      await cache.purgePattern('isr:/content/*')
+
+      // /content (exact) should still be cached
+      expect((await cache.lookup('/content')).status).toBe('fresh')
+      // /content/* should be purged
+      expect((await cache.lookup('/content/article-1')).status).toBe('miss')
+      expect((await cache.lookup('/content/article-2')).status).toBe('miss')
+      // /todos should be unaffected
+      expect((await cache.lookup('/todos')).status).toBe('fresh')
+    })
   })
 
-  it('purges by pattern', async () => {
-    await cache.store('/content', '<html>list</html>')
-    await cache.store('/content/123', '<html>detail 123</html>')
-    await cache.store('/content/456', '<html>detail 456</html>')
-    await cache.store('/todos', '<html>todos</html>')
-
-    await cache.purgePattern('isr:/content/*')
-
-    expect((await cache.lookup('/content')).status).toBe('fresh')
-    expect((await cache.lookup('/content/123')).status).toBe('miss')
-    expect((await cache.lookup('/content/456')).status).toBe('miss')
-    expect((await cache.lookup('/todos')).status).toBe('fresh')
+  describe('full lifecycle', () => {
+    it('miss → store → fresh → purge → miss', async () => {
+      // Step 1: Initial miss
+      let result = await cache.lookup('/todos')
+      expect(result.status).toBe('miss')
+
+      // Step 2: Store
+      await cache.store('/todos', '<html>todos v1</html>')
+
+      // Step 3: Fresh hit
+      result = await cache.lookup('/todos')
+      expect(result.status).toBe('fresh')
+      expect(result.html).toBe('<html>todos v1</html>')
+
+      // Step 4: Purge
+      await cache.purge('/todos')
+
+      // Step 5: Miss again
+      result = await cache.lookup('/todos')
+      expect(result.status).toBe('miss')
+    })
+
+    it('store v1 → purge → store v2 → returns v2', async () => {
+      await cache.store('/todos', '<html>v1</html>')
+      await cache.purge('/todos')
+      await cache.store('/todos', '<html>v2</html>')
+
+      const result = await cache.lookup('/todos')
+      expect(result.status).toBe('fresh')
+      expect(result.html).toBe('<html>v2</html>')
+    })
   })
 })

package/template/src/server/core/__tests__/isr-invalidation.test.ts

@@ -15,6 +15,25 @@ import {
 } from '@server/core/isr-invalidation'
 import { createISRCache } from '@server/core/isr-cache'
 
+// Side-effect: 注册 ISR 路由到全局 registry（purgeAllPages 遍历它）。
+// todos/content 在部分 preset 中不存在 —— 均为可选导入
+const todosIsrModule = '@server/module-todos/isr'
+let hasTodosModule = false
+try {
+  await import(/* @vite-ignore */ todosIsrModule)
+  hasTodosModule = true
+} catch {
+  // preset 无 todos 模块（forum/xbrowser 等）
+}
+const contentIsrModule = '@server/module-content/isr'
+let hasContentModule = false
+try {
+  await import(/* @vite-ignore */ contentIsrModule)
+  hasContentModule = true
+} catch {
+  // preset 无 content 模块
+}
+
 describe('isr-invalidation', () => {
   it('returns null cache when not set', () => {
     expect(getISRCache()).toBeNull()
@@ -63,10 +82,16 @@ describe('isr-invalidation', () => {
 
       await purgeAllPages()
 
-      expect((await cache.lookup('/')).status).toBe('miss')
-      expect((await cache.lookup('/todos')).status).toBe('miss')
-      expect((await cache.lookup('/content')).status).toBe('miss')
-      expect((await cache.lookup('/content/123')).status).toBe('miss')
+      if (hasTodosModule) {
+        // '/' 与 '/todos' 路由由 todos 模块注册，仅含 todos 的 preset 可断言
+        expect((await cache.lookup('/')).status).toBe('miss')
+        expect((await cache.lookup('/todos')).status).toBe('miss')
+      }
+      if (hasContentModule) {
+        // content 相关页仅在 preset 含 content 模块时被注册、才可被清理
+        expect((await cache.lookup('/content')).status).toBe('miss')
+        expect((await cache.lookup('/content/123')).status).toBe('miss')
+      }
     })
   })
 })

package/template/src/server/core/__tests__/isr-registry.test.ts

@@ -0,0 +1,215 @@
+/**
+ * @framework-baseline 560bce7dbeafc84a
+ *
+ * @framework-modify
+ * @reason prettier 格式化导致内容哈希与初始基准漂移，补记说明
+ * @impact 仅格式，无逻辑改动
+ */
+
+import { describe, it, expect, beforeEach } from 'vitest'
+import { createISRRegistry } from '@server/core/isr-registry'
+
+describe('ISR Registry', () => {
+  let registry: ReturnType<typeof createISRRegistry>
+
+  beforeEach(() => {
+    registry = createISRRegistry()
+  })
+
+  describe('register', () => {
+    it('should register a single route', () => {
+      registry.register({
+        module: 'todos',
+        match: '/todos',
+        fetch: async () => ({}),
+        meta: () => ({ title: 'Todos', description: 'Todo list' }),
+      })
+      expect(registry.getAll()).toHaveLength(1)
+    })
+
+    it('should register multiple routes', () => {
+      registry.registerMany([
+        {
+          module: 'todos',
+          match: '/todos',
+          fetch: async () => ({}),
+          meta: () => ({ title: 'Todos', description: '' }),
+        },
+        {
+          module: 'content',
+          match: '/content',
+          fetch: async () => ({}),
+          meta: () => ({ title: 'Content', description: '' }),
+        },
+      ])
+      expect(registry.getAll()).toHaveLength(2)
+    })
+
+    it('should update existing entry on re-register', () => {
+      registry.register({
+        module: 'todos',
+        match: '/todos',
+        fetch: async () => ({}),
+        meta: () => ({ title: 'v1', description: '' }),
+      })
+      registry.register({
+        module: 'todos',
+        match: '/todos',
+        fetch: async () => ({}),
+        meta: () => ({ title: 'v2', description: '' }),
+      })
+      expect(registry.getAll()).toHaveLength(1)
+      expect(registry.getAll()[0].meta({}, '')).toEqual({ title: 'v2', description: '' })
+    })
+  })
+
+  describe('match — exact paths', () => {
+    it('should match exact path', () => {
+      registry.register({
+        module: 'todos',
+        match: '/todos',
+        fetch: async () => ({}),
+        meta: () => ({ title: '', description: '' }),
+      })
+      const entry = registry.match('/todos')
+      expect(entry).not.toBeNull()
+      expect(entry!.module).toBe('todos')
+    })
+
+    it('should not match wrong exact path', () => {
+      registry.register({
+        module: 'todos',
+        match: '/todos',
+        fetch: async () => ({}),
+        meta: () => ({ title: '', description: '' }),
+      })
+      expect(registry.match('/orders')).toBeNull()
+    })
+
+    it('should match root /', () => {
+      registry.register({
+        module: 'home',
+        match: '/',
+        fetch: async () => ({}),
+        meta: () => ({ title: '', description: '' }),
+      })
+      expect(registry.match('/')).not.toBeNull()
+      expect(registry.match('/todos')).toBeNull()
+    })
+  })
+
+  describe('match — prefix paths', () => {
+    it('should match prefix /content/', () => {
+      registry.register({
+        module: 'content',
+        match: '/content/',
+        fetch: async () => ({}),
+        meta: () => ({ title: '', description: '' }),
+      })
+      expect(registry.match('/content/content-1')).not.toBeNull()
+      expect(registry.match('/content/any-id')).not.toBeNull()
+    })
+
+    it('should not match prefix for unrelated path', () => {
+      registry.register({
+        module: 'content',
+        match: '/content/',
+        fetch: async () => ({}),
+        meta: () => ({ title: '', description: '' }),
+      })
+      expect(registry.match('/todos')).toBeNull()
+    })
+
+    it('should prefer exact match over prefix', () => {
+      registry.register({
+        module: 'content-detail',
+        match: '/content/',
+        fetch: async () => ({}),
+        meta: () => ({ title: 'detail', description: '' }),
+      })
+      registry.register({
+        module: 'content-list',
+        match: '/content',
+        fetch: async () => ({}),
+        meta: () => ({ title: 'list', description: '' }),
+      })
+      const exact = registry.match('/content')
+      const prefix = registry.match('/content/article-1')
+      expect(exact!.module).toBe('content-list')
+      expect(prefix!.module).toBe('content-detail')
+    })
+  })
+
+  describe('match — function matchers', () => {
+    it('should match via function', () => {
+      registry.register({
+        module: 'custom',
+        match: pathname => pathname.startsWith('/shop/'),
+        fetch: async () => ({}),
+        meta: () => ({ title: '', description: '' }),
+      })
+      expect(registry.match('/shop/product-1')).not.toBeNull()
+      expect(registry.match('/shop/')).not.toBeNull()
+      expect(registry.match('/other')).toBeNull()
+    })
+  })
+
+  describe('isISRRoute', () => {
+    it('should return true for registered routes', () => {
+      registry.register({
+        module: 'todos',
+        match: '/todos',
+        fetch: async () => ({}),
+        meta: () => ({ title: '', description: '' }),
+      })
+      expect(registry.isISRRoute('/todos')).toBe(true)
+    })
+
+    it('should return false for unregistered routes', () => {
+      expect(registry.isISRRoute('/unknown')).toBe(false)
+    })
+  })
+
+  describe('getExactPaths', () => {
+    it('should return all exact path strings', () => {
+      registry.registerMany([
+        {
+          module: 'a',
+          match: '/a',
+          fetch: async () => ({}),
+          meta: () => ({ title: '', description: '' }),
+        },
+        {
+          module: 'b',
+          match: '/b/',
+          fetch: async () => ({}),
+          meta: () => ({ title: '', description: '' }),
+        },
+        {
+          module: 'c',
+          match: '/c',
+          fetch: async () => ({}),
+          meta: () => ({ title: '', description: '' }),
+        },
+      ])
+      const paths = registry.getExactPaths()
+      expect(paths).toContain('/a')
+      expect(paths).toContain('/b/')
+      expect(paths).toContain('/c')
+      expect(paths).toHaveLength(3)
+    })
+  })
+
+  describe('clear', () => {
+    it('should remove all entries', () => {
+      registry.register({
+        module: 'a',
+        match: '/a',
+        fetch: async () => ({}),
+        meta: () => ({ title: '', description: '' }),
+      })
+      registry.clear()
+      expect(registry.getAll()).toHaveLength(0)
+    })
+  })
+})