create-fullstack-scaffold 0.1.1 → 0.2.0

package/template/src/client/stores/__tests__/authStore.test.ts

@@ -1,11 +1,10 @@
 import { describe, it, expect, beforeEach, vi } from 'vitest'
 import { create } from 'zustand'
+import { persist } from 'zustand/middleware'
+import { apiClient } from '@client/services/apiClient'
+import type { DeveloperProfile } from '@shared/schemas'
 
-interface UserProfile {
-  id: string
-  username: string
-  role: string
-}
+type UserProfile = Pick<DeveloperProfile, 'id' | 'username' | 'role'>
 
 interface AuthState {
   token: string | null
@@ -26,68 +25,188 @@ const createTestStore = () =>
     logout: () => set({ token: null, isAuthenticated: false, user: null }),
   }))
 
+const { mockJson, mockLoginPost, mockRegisterPost } = vi.hoisted(() => {
+  const mockJson = vi.fn()
+  return {
+    mockJson,
+    mockLoginPost: vi.fn().mockResolvedValue({ json: () => mockJson() }),
+    mockRegisterPost: vi.fn().mockResolvedValue({ json: () => mockJson() }),
+  }
+})
+
+vi.mock('@client/services/apiClient', () => ({
+  apiClient: {
+    api: {
+      auth: {
+        login: { $post: mockLoginPost },
+        register: { $post: mockRegisterPost },
+      },
+    },
+  },
+}))
+
+const noopStorage = {
+  getItem: () => null,
+  setItem: () => {},
+  removeItem: () => {},
+}
+
+interface FullAuthState extends AuthState {
+  loading: boolean
+  error: string | null
+  login: (username: string, password: string) => Promise<void>
+  register: (username: string, email: string, password: string) => Promise<void>
+  clearError: () => void
+}
+
+const createFullAuthStore = () =>
+  create<FullAuthState>()(
+    persist(
+      set => ({
+        token: null,
+        isAuthenticated: false,
+        user: null,
+        loading: false,
+        error: null,
+
+        login: async (username: string, password: string) => {
+          set({ loading: true, error: null })
+          try {
+            const response = await apiClient.api.auth.login.$post({
+              json: { account: username, password },
+            })
+            const result = await response.json()
+            if (result.success) {
+              const { token, profile } = result.data
+              set({
+                token,
+                isAuthenticated: true,
+                user: {
+                  id: profile.id,
+                  username: profile.username,
+                  role: profile.role as 'user' | 'admin',
+                },
+                loading: false,
+                error: null,
+              })
+            } else {
+              set({ loading: false, error: result.error })
+            }
+          } catch {
+            set({ loading: false, error: 'Login failed. Please try again.' })
+          }
+        },
+
+        register: async (username: string, email: string, password: string) => {
+          set({ loading: true, error: null })
+          try {
+            const response = await apiClient.api.auth.register.$post({
+              json: { username, email, password },
+            })
+            const result = await response.json()
+            if (result.success) {
+              set({ loading: false, error: null })
+            } else {
+              set({ loading: false, error: result.error })
+            }
+          } catch {
+            set({ loading: false, error: 'Registration failed. Please try again.' })
+          }
+        },
+
+        setAuth: (token: string, user: UserProfile) =>
+          set({
+            token,
+            isAuthenticated: true,
+            user,
+          }),
+
+        setToken: (token: string) =>
+          set({
+            token,
+            isAuthenticated: true,
+          }),
+
+        logout: () =>
+          set({
+            token: null,
+            isAuthenticated: false,
+            user: null,
+            error: null,
+          }),
+
+        clearError: () => set({ error: null }),
+      }),
+      {
+        name: 'auth-token-test',
+        storage: noopStorage as unknown as ReturnType<
+          typeof import('zustand/middleware').createJSONStorage<FullAuthState>
+        >,
+      }
+    )
+  )
+
 describe('authStore', () => {
-  let useAuthStore: ReturnType<typeof createTestStore>
+  let localStore: ReturnType<typeof createTestStore>
 
   beforeEach(() => {
     vi.clearAllMocks()
-    useAuthStore = createTestStore()
+    mockJson.mockReset()
+    localStore = createTestStore()
   })
 
   describe('Initial State', () => {
     it('should have null token and not authenticated', () => {
-      expect(useAuthStore.getState().token).toBeNull()
-      expect(useAuthStore.getState().isAuthenticated).toBe(false)
+      expect(localStore.getState().token).toBeNull()
+      expect(localStore.getState().isAuthenticated).toBe(false)
     })
 
     it('should have null user and not authenticated', () => {
-      expect(useAuthStore.getState().user).toBeNull()
-      expect(useAuthStore.getState().isAuthenticated).toBe(false)
+      expect(localStore.getState().user).toBeNull()
+      expect(localStore.getState().isAuthenticated).toBe(false)
     })
   })
 
   describe('setAuth', () => {
     it('should set token and user', () => {
-      useAuthStore
-        .getState()
-        .setAuth('jwt-token-123', { id: '1', username: 'admin', role: 'admin' })
+      localStore.getState().setAuth('jwt-token-123', { id: '1', username: 'admin', role: 'admin' })
 
-      const state = useAuthStore.getState()
+      const state = localStore.getState()
       expect(state.token).toBe('jwt-token-123')
       expect(state.isAuthenticated).toBe(true)
       expect(state.user).toEqual({ id: '1', username: 'admin', role: 'admin' })
     })
 
     it('should update existing auth state', () => {
-      useAuthStore.getState().setAuth('token-1', { id: '1', username: 'user1', role: 'user' })
-      useAuthStore.getState().setAuth('token-2', { id: '2', username: 'user2', role: 'admin' })
+      localStore.getState().setAuth('token-1', { id: '1', username: 'user1', role: 'user' })
+      localStore.getState().setAuth('token-2', { id: '2', username: 'user2', role: 'admin' })
 
-      const state = useAuthStore.getState()
+      const state = localStore.getState()
       expect(state.token).toBe('token-2')
       expect(state.user?.username).toBe('user2')
     })
 
     it('should set isAuthenticated to true and preserve token', () => {
-      useAuthStore.getState().setAuth('t', { id: '1', username: 'u', role: 'r' })
-      expect(useAuthStore.getState().isAuthenticated).toBe(true)
-      expect(useAuthStore.getState().token).toBe('t')
+      localStore.getState().setAuth('t', { id: '1', username: 'u', role: 'r' })
+      expect(localStore.getState().isAuthenticated).toBe(true)
+      expect(localStore.getState().token).toBe('t')
     })
   })
 
   describe('setToken', () => {
     it('should set token and mark as authenticated', () => {
-      useAuthStore.getState().setToken('new-token')
+      localStore.getState().setToken('new-token')
 
-      const state = useAuthStore.getState()
+      const state = localStore.getState()
       expect(state.token).toBe('new-token')
       expect(state.isAuthenticated).toBe(true)
     })
 
     it('should not modify user when setting token only', () => {
-      useAuthStore.getState().setAuth('old', { id: '1', username: 'user', role: 'user' })
-      useAuthStore.getState().setToken('refreshed-token')
+      localStore.getState().setAuth('old', { id: '1', username: 'user', role: 'user' })
+      localStore.getState().setToken('refreshed-token')
 
-      const state = useAuthStore.getState()
+      const state = localStore.getState()
       expect(state.user).toEqual({ id: '1', username: 'user', role: 'user' })
       expect(state.token).toBe('refreshed-token')
     })
@@ -95,19 +214,19 @@ describe('authStore', () => {
 
   describe('logout', () => {
     it('should clear all auth state', () => {
-      useAuthStore.getState().setAuth('token', { id: '1', username: 'user', role: 'user' })
-      useAuthStore.getState().logout()
+      localStore.getState().setAuth('token', { id: '1', username: 'user', role: 'user' })
+      localStore.getState().logout()
 
-      const state = useAuthStore.getState()
+      const state = localStore.getState()
       expect(state.token).toBeNull()
       expect(state.isAuthenticated).toBe(false)
       expect(state.user).toBeNull()
     })
 
     it('should be safe to call logout when already logged out', () => {
-      useAuthStore.getState().logout()
+      localStore.getState().logout()
 
-      const state = useAuthStore.getState()
+      const state = localStore.getState()
       expect(state.token).toBeNull()
       expect(state.isAuthenticated).toBe(false)
       expect(state.user).toBeNull()
@@ -116,15 +235,15 @@ describe('authStore', () => {
 
   describe('Full auth lifecycle', () => {
     it('should handle login -> use -> logout flow', () => {
-      expect(useAuthStore.getState().isAuthenticated).toBe(false)
+      expect(localStore.getState().isAuthenticated).toBe(false)
 
-      useAuthStore.getState().setAuth('jwt', { id: '1', username: 'admin', role: 'admin' })
-      expect(useAuthStore.getState().isAuthenticated).toBe(true)
-      expect(useAuthStore.getState().user?.role).toBe('admin')
+      localStore.getState().setAuth('jwt', { id: '1', username: 'admin', role: 'admin' })
+      expect(localStore.getState().isAuthenticated).toBe(true)
+      expect(localStore.getState().user?.role).toBe('admin')
 
-      useAuthStore.getState().logout()
-      expect(useAuthStore.getState().isAuthenticated).toBe(false)
-      expect(useAuthStore.getState().user).toBeNull()
+      localStore.getState().logout()
+      expect(localStore.getState().isAuthenticated).toBe(false)
+      expect(localStore.getState().user).toBeNull()
     })
   })
 
@@ -137,3 +256,139 @@ describe('authStore', () => {
     })
   })
 })
+
+describe('authStore - login action', () => {
+  let store: ReturnType<typeof createFullAuthStore>
+
+  beforeEach(() => {
+    vi.clearAllMocks()
+    mockJson.mockReset()
+    store = createFullAuthStore()
+  })
+
+  it('should login successfully', async () => {
+    mockJson.mockResolvedValue({
+      success: true,
+      data: {
+        token: 'jwt-abc',
+        profile: { id: '1', username: 'testuser', role: 'user' },
+      },
+    })
+
+    await store.getState().login('testuser', 'pass123')
+
+    const state = store.getState()
+    expect(state.token).toBe('jwt-abc')
+    expect(state.isAuthenticated).toBe(true)
+    expect(state.user).toEqual({ id: '1', username: 'testuser', role: 'user' })
+    expect(state.loading).toBe(false)
+    expect(state.error).toBeNull()
+  })
+
+  it('should handle login failure response', async () => {
+    mockJson.mockResolvedValue({
+      success: false,
+      error: 'Invalid credentials',
+    })
+
+    await store.getState().login('wrong', 'wrong')
+
+    const state = store.getState()
+    expect(state.isAuthenticated).toBe(false)
+    expect(state.error).toBe('Invalid credentials')
+    expect(state.loading).toBe(false)
+  })
+
+  it('should handle login network error', async () => {
+    mockLoginPost.mockRejectedValueOnce(new Error('Network error'))
+
+    await store.getState().login('user', 'pass')
+
+    const state = store.getState()
+    expect(state.error).toBe('Login failed. Please try again.')
+    expect(state.loading).toBe(false)
+  })
+
+  it('should set loading to true during login', async () => {
+    let resolvePromise!: (value: unknown) => void
+    mockLoginPost.mockReturnValueOnce(
+      new Promise(r => {
+        resolvePromise = r
+      })
+    )
+
+    const loginPromise = store.getState().login('user', 'pass')
+    expect(store.getState().loading).toBe(true)
+
+    resolvePromise({ json: () => Promise.resolve({ success: false, error: 'fail' }) })
+    await loginPromise
+
+    expect(store.getState().loading).toBe(false)
+  })
+})
+
+describe('authStore - register action', () => {
+  let store: ReturnType<typeof createFullAuthStore>
+
+  beforeEach(() => {
+    vi.clearAllMocks()
+    mockJson.mockReset()
+    store = createFullAuthStore()
+  })
+
+  it('should register successfully', async () => {
+    mockJson.mockResolvedValue({
+      success: true,
+      data: { id: '2', username: 'newuser' },
+    })
+
+    await store.getState().register('newuser', 'new@test.com', 'pass123')
+
+    const state = store.getState()
+    expect(state.loading).toBe(false)
+    expect(state.error).toBeNull()
+  })
+
+  it('should handle register failure response', async () => {
+    mockJson.mockResolvedValue({
+      success: false,
+      error: 'Username already taken',
+    })
+
+    await store.getState().register('taken', 'taken@test.com', 'pass123')
+
+    const state = store.getState()
+    expect(state.error).toBe('Username already taken')
+    expect(state.loading).toBe(false)
+  })
+
+  it('should handle register network error', async () => {
+    mockRegisterPost.mockRejectedValueOnce(new Error('Network error'))
+
+    await store.getState().register('user', 'e@e.com', 'pass')
+
+    const state = store.getState()
+    expect(state.error).toBe('Registration failed. Please try again.')
+    expect(state.loading).toBe(false)
+  })
+})
+
+describe('authStore - clearError action', () => {
+  let store: ReturnType<typeof createFullAuthStore>
+
+  beforeEach(() => {
+    vi.clearAllMocks()
+    mockJson.mockReset()
+    store = createFullAuthStore()
+  })
+
+  it('should clear error', async () => {
+    mockJson.mockResolvedValue({ success: false, error: 'test error' })
+    await store.getState().login('x', 'y')
+
+    expect(store.getState().error).toBe('test error')
+
+    store.getState().clearError()
+    expect(store.getState().error).toBeNull()
+  })
+})

package/template/src/client/stores/__tests__/todoStore.test.ts

@@ -127,23 +127,13 @@ describe('Todo Store', () => {
       expect(state.error).toBeNull()
     })
 
-    it('should fetch todos with { items } response format', async () => {
-      const todos = [createMockTodo({ id: 1 })]
-      mockJson.mockResolvedValue({ success: true, data: { items: todos } })
-
-      await useTodoStore.getState().fetchTodos()
-
-      expect(useTodoStore.getState().todos).toEqual(todos)
-      expect(useTodoStore.getState().loading).toBe(false)
-    })
-
-    it('should handle empty items in object response', async () => {
-      mockJson.mockResolvedValue({ success: true, data: {} })
+    it('should handle empty array response', async () => {
+      mockJson.mockResolvedValue({ success: true, data: [] })
 
       await useTodoStore.getState().fetchTodos()
 
       expect(useTodoStore.getState().todos).toEqual([])
-      expect(useTodoStore.getState().error).toBeNull()
+      expect(useTodoStore.getState().loading).toBe(false)
     })
 
     it('should handle failed response', async () => {
@@ -434,13 +424,13 @@ describe('Todo Store', () => {
       expect(useTodoStore.getState().attachments.get(1)).toEqual(attachments)
     })
 
-    it('should fetch attachments with items response format', async () => {
-      const attachments = [createMockAttachment()]
-      mockJson.mockResolvedValue({ success: true, data: { items: attachments } })
+    it('should store data directly even if not an array', async () => {
+      const obj = { items: [createMockAttachment()] }
+      mockJson.mockResolvedValue({ success: true, data: obj })
 
       await useTodoStore.getState().fetchAttachments(1)
 
-      expect(useTodoStore.getState().attachments.get(1)).toEqual(attachments)
+      expect(useTodoStore.getState().attachments.get(1)).toEqual(obj)
     })
 
     it('should handle fetch error gracefully', async () => {

package/template/src/client/stores/authStore.ts

@@ -1,20 +1,23 @@
 import { create } from 'zustand'
 import { persist } from 'zustand/middleware'
+import { apiClient } from '@client/services/apiClient'
+import type { DeveloperProfile } from '@shared/schemas'
 
-interface UserProfile {
-  id: string
-  username: string
-  role: string
-}
+type UserProfile = Pick<DeveloperProfile, 'id' | 'username' | 'role'>
 
 interface AuthState {
   token: string | null
   isAuthenticated: boolean
   user: UserProfile | null
+  loading: boolean
+  error: string | null
 
+  login: (username: string, password: string) => Promise<void>
+  register: (username: string, email: string, password: string) => Promise<void>
   setAuth: (token: string, user: UserProfile) => void
   setToken: (token: string) => void
   logout: () => void
+  clearError: () => void
 }
 
 export const useAuthStore = create<AuthState>()(
@@ -23,6 +26,53 @@ export const useAuthStore = create<AuthState>()(
       token: null,
       isAuthenticated: false,
       user: null,
+      loading: false,
+      error: null,
+
+      login: async (username: string, password: string) => {
+        set({ loading: true, error: null })
+        try {
+          const response = await apiClient.api.auth.login.$post({
+            json: { account: username, password },
+          })
+          const result = await response.json()
+          if (result.success) {
+            const { token, profile } = result.data
+            set({
+              token,
+              isAuthenticated: true,
+              user: {
+                id: profile.id,
+                username: profile.username,
+                role: profile.role as 'user' | 'admin',
+              },
+              loading: false,
+              error: null,
+            })
+          } else {
+            set({ loading: false, error: result.error })
+          }
+        } catch {
+          set({ loading: false, error: 'Login failed. Please try again.' })
+        }
+      },
+
+      register: async (username: string, email: string, password: string) => {
+        set({ loading: true, error: null })
+        try {
+          const response = await apiClient.api.auth.register.$post({
+            json: { username, email, password },
+          })
+          const result = await response.json()
+          if (result.success) {
+            set({ loading: false, error: null })
+          } else {
+            set({ loading: false, error: result.error })
+          }
+        } catch {
+          set({ loading: false, error: 'Registration failed. Please try again.' })
+        }
+      },
 
       setAuth: (token: string, user: UserProfile) =>
         set({
@@ -42,7 +92,10 @@ export const useAuthStore = create<AuthState>()(
           token: null,
           isAuthenticated: false,
           user: null,
+          error: null,
         }),
+
+      clearError: () => set({ error: null }),
     }),
     {
       name: 'auth-token',

package/template/src/client/stores/chatWSStore.ts

@@ -11,6 +11,7 @@ interface WSMessage {
 interface WSState {
   status: WSStatus
   messages: WSMessage[]
+  error: string | null
 
   connect: () => void
   disconnect: () => void
@@ -19,6 +20,7 @@ interface WSState {
   broadcast: (params: { message: string; timestamp: number }) => void
   notification: (params: { title: string; body: string; timestamp: number }) => void
   clearMessages: () => void
+  clearError: () => void
 }
 
 let wsClient: WSClient<ChatProtocol> | null = null
@@ -26,6 +28,7 @@ let wsClient: WSClient<ChatProtocol> | null = null
 export const useChatWsStore = create<WSState>((set, get) => ({
   status: 'closed',
   messages: [],
+  error: null,
 
   connect: () => {
     if (wsClient) return
@@ -87,6 +90,7 @@ export const useChatWsStore = create<WSState>((set, get) => ({
       }))
     } catch (error) {
       console.error('Echo failed:', error)
+      set({ error: error instanceof Error ? error.message : 'Echo failed' })
     }
   },
 
@@ -103,6 +107,7 @@ export const useChatWsStore = create<WSState>((set, get) => ({
       }))
     } catch (error) {
       console.error('Ping failed:', error)
+      set({ error: error instanceof Error ? error.message : 'Ping failed' })
     }
   },
 
@@ -119,4 +124,8 @@ export const useChatWsStore = create<WSState>((set, get) => ({
   clearMessages: () => {
     set({ messages: [] })
   },
+
+  clearError: () => {
+    set({ error: null })
+  },
 }))

package/template/src/client/stores/notificationStore.ts

@@ -91,6 +91,7 @@ export const useNotificationStore = create<NotificationState>(set => ({
       }
     } catch (error) {
       console.error('Failed to mark as read:', error)
+      set({ error: error instanceof Error ? error.message : 'Unknown error' })
     }
   },
 
@@ -106,6 +107,7 @@ export const useNotificationStore = create<NotificationState>(set => ({
       }
     } catch (error) {
       console.error('Failed to mark all as read:', error)
+      set({ error: error instanceof Error ? error.message : 'Unknown error' })
     }
   },
 
@@ -127,6 +129,7 @@ export const useNotificationStore = create<NotificationState>(set => ({
       }
     } catch (error) {
       console.error('Failed to delete:', error)
+      set({ error: error instanceof Error ? error.message : 'Unknown error' })
     }
   },
 
@@ -139,6 +142,7 @@ export const useNotificationStore = create<NotificationState>(set => ({
       }
     } catch (error) {
       console.error('Failed to fetch unread count:', error)
+      set({ error: error instanceof Error ? error.message : 'Unknown error' })
     }
   },