create-fullstack-scaffold 0.4.9 → 0.4.10

package/template/src/merchant/stores/__tests__/merchantStore.test.ts

@@ -0,0 +1,317 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import type { Merchant, MerchantStats } from '@shared/schemas'
+
+interface MerchantState {
+  merchant: Merchant | null
+  token: string | null
+  isAuthenticated: boolean
+  stats: MerchantStats | null
+  loading: boolean
+  error: string | null
+  startLoading: (message?: string) => void
+  stopLoading: () => void
+  checkAuth: () => Promise<void>
+  login: (username: string, password: string) => Promise<void>
+  logout: () => void
+  fetchStats: () => Promise<void>
+  setLoading: (loading: boolean) => void
+  setError: (error: string | null) => void
+}
+
+const mockMerchant: Merchant = {
+  id: 1,
+  userId: 'user-1',
+  tenantId: 100,
+  businessName: 'Test Shop',
+  businessType: 'retail',
+  status: 'active',
+  description: 'A test shop',
+  phone: '1234567890',
+  email: 'shop@test.com',
+  address: '123 Test St',
+  createdAt: '2024-01-01T00:00:00Z',
+  updatedAt: '2024-01-01T00:00:00Z',
+}
+
+const mockStats: MerchantStats = {
+  totalOrders: 150,
+  totalRevenue: 50000,
+  totalProducts: 80,
+  activeProducts: 65,
+  pendingOrders: 12,
+  thisMonthRevenue: 8500,
+}
+
+const mockCheckAuthResponse = {
+  success: true,
+  data: mockMerchant,
+}
+
+const mockLoginResponse = {
+  success: true,
+  data: {
+    merchant: mockMerchant,
+    token: 'merchant-token-123',
+  },
+}
+
+const mockStatsResponse = {
+  success: true,
+  data: mockStats,
+}
+
+// Extract mock functions to top level (same pattern as todoStore.test.ts)
+const mockMeGet = vi.fn(async () => ({
+  json: async () => mockCheckAuthResponse,
+}))
+const mockLoginPost = vi.fn(async () => ({
+  json: async () => mockLoginResponse,
+}))
+const mockStatsGet = vi.fn(async () => ({
+  json: async () => mockStatsResponse,
+}))
+
+vi.mock('@client/services/apiClient', () => ({
+  apiClient: {
+    api: {
+      merchant: {
+        me: { $get: mockMeGet },
+        login: { $post: mockLoginPost },
+        stats: { $get: mockStatsGet },
+      },
+    },
+  },
+}))
+
+describe('useMerchantStore', () => {
+  let useMerchantStore: {
+    getState: () => MerchantState
+    setState: (s: Partial<MerchantState>) => void
+  }
+
+  beforeEach(async () => {
+    const mod = await import('../merchantStore')
+    useMerchantStore = mod.useMerchantStore
+    useMerchantStore.setState({
+      merchant: null,
+      token: null,
+      isAuthenticated: false,
+      stats: null,
+      loading: false,
+      error: null,
+    })
+    vi.clearAllMocks()
+  })
+
+  it('should have correct initial state', () => {
+    const state = useMerchantStore.getState()
+    expect(state.merchant).toBeNull()
+    expect(state.token).toBeNull()
+    expect(state.isAuthenticated).toBe(false)
+    expect(state.stats).toBeNull()
+    expect(state.loading).toBe(false)
+    expect(state.error).toBeNull()
+  })
+
+  describe('checkAuth', () => {
+    it('should set merchant and isAuthenticated on successful check', async () => {
+      await useMerchantStore.getState().checkAuth()
+
+      const state = useMerchantStore.getState()
+      expect(state.merchant).toEqual(mockMerchant)
+      expect(state.isAuthenticated).toBe(true)
+      expect(state.loading).toBe(false)
+      expect(state.error).toBeNull()
+    })
+
+    it('should clear merchant on failed check (success: false)', async () => {
+      mockMeGet.mockImplementationOnce(
+        async () =>
+          ({
+            json: async () => ({
+              success: false,
+              error: 'Not authenticated',
+            }),
+          } as never)
+      )
+
+      await useMerchantStore.getState().checkAuth()
+
+      const state = useMerchantStore.getState()
+      expect(state.merchant).toBeNull()
+      expect(state.isAuthenticated).toBe(false)
+      expect(state.loading).toBe(false)
+    })
+
+    it('should handle network error gracefully', async () => {
+      mockMeGet.mockImplementationOnce(async () => {
+        throw new Error('Network error')
+      })
+
+      await useMerchantStore.getState().checkAuth()
+
+      const state = useMerchantStore.getState()
+      expect(state.merchant).toBeNull()
+      expect(state.isAuthenticated).toBe(false)
+      expect(state.error).toBe('Authentication failed')
+      expect(state.loading).toBe(false)
+    })
+  })
+
+  describe('login', () => {
+    it('should set merchant, token, isAuthenticated on successful login', async () => {
+      await useMerchantStore.getState().login('testmerchant', 'password123')
+
+      const state = useMerchantStore.getState()
+      expect(state.merchant).toEqual(mockMerchant)
+      expect(state.token).toBe('merchant-token-123')
+      expect(state.isAuthenticated).toBe(true)
+      expect(state.loading).toBe(false)
+      expect(state.error).toBeNull()
+    })
+
+    it('should set error on failed login (success: false)', async () => {
+      mockLoginPost.mockImplementationOnce(
+        async () =>
+          ({
+            json: async () => ({
+              success: false,
+              error: 'Invalid username or password',
+            }),
+          } as never)
+      )
+
+      await useMerchantStore.getState().login('wrong', 'creds')
+
+      const state = useMerchantStore.getState()
+      expect(state.merchant).toBeNull()
+      expect(state.token).toBeNull()
+      expect(state.isAuthenticated).toBe(false)
+      expect(state.error).toBe('Invalid username or password')
+      expect(state.loading).toBe(false)
+    })
+
+    it('should handle network error', async () => {
+      mockLoginPost.mockImplementationOnce(async () => {
+        throw new Error('Network error')
+      })
+
+      await useMerchantStore.getState().login('testmerchant', 'password123')
+
+      const state = useMerchantStore.getState()
+      expect(state.merchant).toBeNull()
+      expect(state.isAuthenticated).toBe(false)
+      expect(state.error).toBe('Network error')
+      expect(state.loading).toBe(false)
+    })
+
+    it('should set loading state during login', async () => {
+      let resolveResponse!: () => void
+      const responsePromise = new Promise<void>(resolve => {
+        resolveResponse = resolve
+      })
+
+      mockLoginPost.mockImplementationOnce(async () => {
+        await responsePromise
+        return {
+          json: async () => mockLoginResponse,
+        }
+      })
+
+      const loginPromise = useMerchantStore.getState().login('testmerchant', 'password123')
+
+      expect(useMerchantStore.getState().loading).toBe(true)
+
+      resolveResponse()
+      await loginPromise
+
+      expect(useMerchantStore.getState().loading).toBe(false)
+    })
+  })
+
+  describe('logout', () => {
+    it('should clear all auth state on logout', async () => {
+      await useMerchantStore.getState().login('testmerchant', 'password123')
+      expect(useMerchantStore.getState().isAuthenticated).toBe(true)
+
+      await useMerchantStore.getState().fetchStats()
+      expect(useMerchantStore.getState().stats).toEqual(mockStats)
+
+      useMerchantStore.getState().logout()
+
+      const state = useMerchantStore.getState()
+      expect(state.merchant).toBeNull()
+      expect(state.token).toBeNull()
+      expect(state.isAuthenticated).toBe(false)
+      expect(state.stats).toBeNull()
+    })
+  })
+
+  describe('fetchStats', () => {
+    it('should populate stats on successful fetch', async () => {
+      await useMerchantStore.getState().fetchStats()
+
+      const state = useMerchantStore.getState()
+      expect(state.stats).toEqual(mockStats)
+      expect(state.loading).toBe(false)
+      expect(state.error).toBeNull()
+    })
+
+    it('should handle failed response', async () => {
+      mockStatsGet.mockImplementationOnce(
+        async () =>
+          ({
+            json: async () => ({
+              success: false,
+              error: 'Unauthorized',
+            }),
+          } as never)
+      )
+
+      await useMerchantStore.getState().fetchStats()
+
+      const state = useMerchantStore.getState()
+      expect(state.stats).toBeNull()
+      expect(state.loading).toBe(false)
+    })
+
+    it('should handle network error', async () => {
+      mockStatsGet.mockImplementationOnce(async () => {
+        throw new Error('Network error')
+      })
+
+      await useMerchantStore.getState().fetchStats()
+
+      const state = useMerchantStore.getState()
+      expect(state.stats).toBeNull()
+      expect(state.error).toBe('Failed to fetch statistics')
+      expect(state.loading).toBe(false)
+    })
+  })
+
+  describe('setLoading / setError', () => {
+    it('should update loading state', () => {
+      useMerchantStore.getState().setLoading(true)
+      expect(useMerchantStore.getState().loading).toBe(true)
+
+      useMerchantStore.getState().setLoading(false)
+      expect(useMerchantStore.getState().loading).toBe(false)
+    })
+
+    it('should update error state', () => {
+      useMerchantStore.getState().setError('Something went wrong')
+      expect(useMerchantStore.getState().error).toBe('Something went wrong')
+
+      useMerchantStore.getState().setError(null)
+      expect(useMerchantStore.getState().error).toBeNull()
+    })
+
+    it('should update loading state via startLoading/stopLoading', () => {
+      useMerchantStore.getState().startLoading()
+      expect(useMerchantStore.getState().loading).toBe(true)
+
+      useMerchantStore.getState().stopLoading()
+      expect(useMerchantStore.getState().loading).toBe(false)
+    })
+  })
+})

package/template/src/merchant/stores/merchantStore.ts

@@ -1,14 +1,10 @@
 import { create } from 'zustand'
-import type { User } from '@shared/schemas'
-
-interface MerchantStats {
-  totalSales: number
-  totalOrders: number
-  pendingOrders: number
-}
+import { apiClient } from '@client/services/apiClient'
+import type { Merchant, MerchantStats } from '@shared/schemas'
 
 interface MerchantState {
-  user: User | null
+  merchant: Merchant | null
+  token: string | null
   isAuthenticated: boolean
   stats: MerchantStats | null
   loading: boolean
@@ -24,7 +20,8 @@ interface MerchantState {
 }
 
 export const useMerchantStore = create<MerchantState>(set => ({
-  user: null,
+  merchant: null,
+  token: null,
   isAuthenticated: false,
   stats: null,
   loading: false,
@@ -36,16 +33,16 @@ export const useMerchantStore = create<MerchantState>(set => ({
   checkAuth: async () => {
     set({ loading: true, error: null })
     try {
-      const response = await fetch('/api/merchant/me')
-      const result = (await response.json()) as { success?: boolean; data?: User }
+      const response = await apiClient.api.merchant.me.$get()
+      const result = await response.json()
       if (result.success === true && result.data) {
-        set({ user: result.data, isAuthenticated: true })
+        set({ merchant: result.data, isAuthenticated: true })
       } else {
-        set({ user: null, isAuthenticated: false })
+        set({ merchant: null, isAuthenticated: false })
       }
     } catch (error) {
       console.error('Auth check failed:', error)
-      set({ user: null, isAuthenticated: false, error: 'Authentication failed' })
+      set({ merchant: null, isAuthenticated: false, error: 'Authentication failed' })
     } finally {
       set({ loading: false })
     }
@@ -54,18 +51,18 @@ export const useMerchantStore = create<MerchantState>(set => ({
   login: async (username: string, password: string) => {
     set({ loading: true, error: null })
     try {
-      const response = await fetch('/api/merchant/login', {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-        },
-        body: JSON.stringify({ username, password }),
+      const response = await apiClient.api.merchant.login.$post({
+        json: { username, password },
       })
-      const result = (await response.json()) as { success?: boolean; data?: User; error?: string }
+      const result = await response.json()
       if (result.success === true && result.data) {
-        set({ user: result.data, isAuthenticated: true })
-      } else {
-        set({ error: result.error || 'Login failed' })
+        set({
+          merchant: result.data.merchant,
+          token: result.data.token,
+          isAuthenticated: true,
+        })
+      } else if (result.success === false) {
+        set({ error: result.error })
       }
     } catch (error) {
       console.error('Login failed:', error)
@@ -76,14 +73,14 @@ export const useMerchantStore = create<MerchantState>(set => ({
   },
 
   logout: () => {
-    set({ user: null, isAuthenticated: false, stats: null })
+    set({ merchant: null, token: null, isAuthenticated: false, stats: null })
   },
 
   fetchStats: async () => {
     set({ loading: true, error: null })
     try {
-      const response = await fetch('/api/merchant/stats')
-      const result = (await response.json()) as { success?: boolean; data?: MerchantStats }
+      const response = await apiClient.api.merchant.stats.$get()
+      const result = await response.json()
       if (result.success === true && result.data) {
         set({ stats: result.data })
       }

package/template/src/server/db/schema/index.ts

@@ -15,3 +15,5 @@ export * from './contents'
 export * from './developers'
 export * from './plugins'
 export * from './tenants'
+export * from './merchants'
+export * from './products'

package/template/src/server/db/schema/merchants.ts

@@ -0,0 +1,26 @@
+import { sqliteTable, text, integer } from 'drizzle-orm/sqlite-core'
+
+export const merchantStatuses = ['active', 'inactive', 'suspended'] as const
+export type MerchantStatus = (typeof merchantStatuses)[number]
+
+export const businessTypes = ['retail', 'wholesale', 'service', 'restaurant'] as const
+export type BusinessType = (typeof businessTypes)[number]
+
+export const merchants = sqliteTable('merchants', {
+  id: integer('id').primaryKey({ autoIncrement: true }),
+  userId: text('user_id').notNull(),
+  tenantId: integer('tenant_id').notNull(),
+  businessName: text('business_name').notNull(),
+  businessType: text('business_type', { enum: businessTypes }).notNull().default('retail'),
+  status: text('status', { enum: merchantStatuses }).notNull().default('active'),
+  description: text('description'),
+  phone: text('phone'),
+  email: text('email'),
+  address: text('address'),
+  password: text('password').notNull(), // Simplified - use bcrypt hash in production
+  createdAt: text('created_at').notNull(),
+  updatedAt: text('updated_at').notNull(),
+})
+
+export type MerchantTable = typeof merchants.$inferSelect
+export type NewMerchant = typeof merchants.$inferInsert

package/template/src/server/db/schema/products.ts

@@ -0,0 +1,25 @@
+import { sqliteTable, integer, text } from 'drizzle-orm/sqlite-core'
+import { sql } from 'drizzle-orm'
+
+export const productStatuses = ['active', 'inactive', 'out_of_stock'] as const
+export type ProductStatus = (typeof productStatuses)[number]
+
+export const products = sqliteTable('products', {
+  id: text('id').primaryKey(),
+  name: text('name').notNull(),
+  description: text('description'),
+  price: integer('price').notNull(), // 单位：分
+  status: text('status', { enum: productStatuses }).notNull().default('active'),
+  stock: integer('stock').notNull().default(0),
+  imageUrl: text('image_url'),
+  merchantId: integer('merchant_id').notNull(), // Changed to integer to match merchants.id
+  createdAt: integer('created_at', { mode: 'timestamp' })
+    .notNull()
+    .default(sql`(unixepoch() * 1000)`),
+  updatedAt: integer('updated_at', { mode: 'timestamp' })
+    .notNull()
+    .default(sql`(unixepoch() * 1000)`),
+})
+
+export type Product = typeof products.$inferSelect
+export type NewProduct = typeof products.$inferInsert