create-fullstack-scaffold 0.4.9 → 0.4.10

package/template/src/server/module-tenant/__tests__/tenant-service.test.ts

@@ -0,0 +1,152 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest'
+import { setupTestDatabase, cleanupTestDatabase } from '@server/db/test-setup'
+import {
+  listTenants,
+  getTenantById,
+  getTenantBySlug,
+  createTenant,
+  updateTenant,
+  deleteTenant,
+} from '../services/tenant-service'
+import type { CreateTenantInput } from '@shared/schemas'
+
+describe('Tenant Service', () => {
+  beforeAll(async () => {
+    await setupTestDatabase()
+  })
+
+  afterAll(async () => {
+    await cleanupTestDatabase()
+  })
+
+  describe('listTenants', () => {
+    it('should return paginated list', async () => {
+      const result = await listTenants(1, 20)
+      expect(result).toHaveProperty('items')
+      expect(result).toHaveProperty('total')
+      expect(result).toHaveProperty('page', 1)
+      expect(result).toHaveProperty('pageSize', 20)
+      expect(Array.isArray(result.items)).toBe(true)
+    })
+
+    it('should filter by status', async () => {
+      const result = await listTenants(1, 20, { status: 'active' })
+      for (const item of result.items) {
+        expect(item.status).toBe('active')
+      }
+    })
+
+    it('should filter by plan', async () => {
+      const result = await listTenants(1, 20, { plan: 'pro' })
+      for (const item of result.items) {
+        expect(item.plan).toBe('pro')
+      }
+    })
+  })
+
+  describe('getTenantById', () => {
+    it('should return null for non-existent id', async () => {
+      const result = await getTenantById(99999)
+      expect(result).toBeNull()
+    })
+
+    it('should return tenant for valid id', async () => {
+      const list = await listTenants(1, 1)
+      if (list.items.length > 0) {
+        const tenant = await getTenantById(list.items[0].id)
+        expect(tenant).not.toBeNull()
+        expect(tenant!.id).toBe(list.items[0].id)
+        expect(tenant).toHaveProperty('name')
+        expect(tenant).toHaveProperty('slug')
+      }
+    })
+  })
+
+  describe('getTenantBySlug', () => {
+    it('should return null for non-existent slug', async () => {
+      const result = await getTenantBySlug('non-existent-slug')
+      expect(result).toBeNull()
+    })
+
+    it('should return tenant by slug', async () => {
+      const result = await getTenantBySlug('demo')
+      expect(result).not.toBeNull()
+      expect(result!.slug).toBe('demo')
+    })
+  })
+
+  describe('createTenant', () => {
+    it('should create a tenant with defaults', async () => {
+      const input: CreateTenantInput = {
+        name: 'New Corp',
+        slug: 'new-corp',
+        plan: 'free',
+        maxUsers: 5,
+        settings: null,
+      }
+      const result = await createTenant(input)
+      expect(result.name).toBe('New Corp')
+      expect(result.slug).toBe('new-corp')
+      expect(result.status).toBe('trial')
+      expect(result.plan).toBe('free')
+    })
+
+    it('should reject duplicate slug', async () => {
+      await expect(
+        createTenant({
+          name: 'Duplicate',
+          slug: 'demo',
+          plan: 'free',
+          maxUsers: 5,
+          settings: null,
+        })
+      ).rejects.toThrow(/already exists/)
+    })
+  })
+
+  describe('updateTenant', () => {
+    it('should return null for non-existent id', async () => {
+      const result = await updateTenant(99999, { name: 'Updated' })
+      expect(result).toBeNull()
+    })
+
+    it('should update tenant fields', async () => {
+      // Create a tenant to update
+      const created = await createTenant({
+        name: 'Update Test',
+        slug: 'update-test',
+        plan: 'free',
+        maxUsers: 5,
+        settings: null,
+      })
+
+      const result = await updateTenant(created.id, { name: 'Updated Name' })
+      expect(result).not.toBeNull()
+      expect(result!.name).toBe('Updated Name')
+    })
+  })
+
+  describe('deleteTenant', () => {
+    it('should return false for non-existent id', async () => {
+      const result = await deleteTenant(99999)
+      expect(result).toBe(false)
+    })
+
+    it('should delete and return true', async () => {
+      const created = await createTenant({
+        name: 'Delete Test',
+        slug: 'delete-test',
+        plan: 'free',
+        maxUsers: 5,
+        settings: null,
+      })
+
+      const result = await deleteTenant(created.id)
+      expect(result).toBe(true)
+
+      // Verify deleted
+      const found = await getTenantById(created.id)
+      expect(found).toBeNull()
+    })
+  })
+})

package/template/src/server/module-tenant/module.ts

@@ -24,6 +24,7 @@ const tenantManifest: ModuleManifest = {
   dbSchemas: {
     files: ['tenants'],
     hasSeed: true,
+    seed: { serviceFile: 'tenant-service', functionName: 'seedTenantsIfEmpty' },
   },
 }
 

package/template/src/server/module-tenant/services/tenant-service.ts

@@ -203,7 +203,7 @@ export async function updateTenant(id: number, input: UpdateTenantInput): Promis
   }
 
   if (input.name !== undefined) {
-    updateData.name = input.name
+    updateData.name = input.name ?? undefined
   }
 
   if (input.status !== undefined && input.status !== null) {
@@ -222,42 +222,6 @@ export async function updateTenant(id: number, input: UpdateTenantInput): Promis
     updateData.settings = input.settings ? JSON.stringify(input.settings) : null
   }
 
-  if (input.name !== undefined) {
-    updateData.name = input.name
-  }
-
-  if (input.status !== undefined && input.status !== null) {
-    updateData.status = input.status
-  }
-
-  if (input.plan !== undefined && input.plan !== null) {
-    updateData.plan = input.plan
-  }
-
-  if (input.maxUsers !== undefined && input.maxUsers !== null) {
-    updateData.maxUsers = input.maxUsers
-  }
-
-  if (input.name !== undefined) {
-    updateData.name = input.name
-  }
-
-  if (input.status !== undefined && input.status !== null) {
-    ;(updateData as Record<string, unknown>).status = input.status
-  }
-
-  if (input.plan !== undefined && input.plan !== null) {
-    ;(updateData as Record<string, unknown>).plan = input.plan
-  }
-
-  if (input.maxUsers !== undefined && input.maxUsers !== null) {
-    ;(updateData as Record<string, unknown>).maxUsers = input.maxUsers
-  }
-
-  if (input.settings !== undefined) {
-    updateData.settings = input.settings ? JSON.stringify(input.settings) : null
-  }
-
   const result = await db.update(tenants).set(updateData).where(eq(tenants.id, id)).returning()
 
   if (result.length === 0) return null

package/template/src/server/module-ticket/module.ts

@@ -24,6 +24,7 @@ const ticketManifest: ModuleManifest = {
   dbSchemas: {
     files: ['tickets'],
     hasSeed: true,
+    seed: { serviceFile: 'ticket-service', functionName: 'seedTicketsIfEmpty' },
   },
 }
 

package/template/src/server/module-ticket/routes/ticket-routes.ts

@@ -10,7 +10,7 @@ import {
   CreateTicketSchema,
   UpdateTicketSchema,
   TicketListSchema,
-  DeleteResultSchema,
+  TicketDeleteResultSchema,
   ReplyTicketSchema,
 } from '@shared/modules/ticket'
 
@@ -112,7 +112,7 @@ const deleteRoute = createRoute({
     params: TicketSchema.pick({ id: true }),
   },
   responses: {
-    200: successResponse(DeleteResultSchema, 'Ticket deleted'),
+    200: successResponse(TicketDeleteResultSchema, 'Ticket deleted'),
     401: errorResponse('Unauthorized'),
     403: errorResponse('Forbidden'),
     404: errorResponse('Ticket not found'),

package/template/src/server/module-todos/module.ts

@@ -24,7 +24,10 @@ const todosManifest: ModuleManifest = {
   dbSchemas: {
     files: ['todos', 'todo-attachments'],
     hasSeed: true,
+    seed: { serviceFile: 'todo-service', functionName: 'seedTodosIfEmpty' },
   },
+
+  cliModule: { dir: 'todo', registerFunction: 'registerTodoCommands' },
 }
 
 export default todosManifest

package/template/src/server/route-registry.ts

@@ -22,6 +22,8 @@ import { dashboardRoutes } from './module-admin/routes/dashboard-routes'
 import { cartRoutes } from './module-order/routes/cart-routes'
 import { ordersMockRoutes } from './module-order/routes/orders-mock-routes'
 import { topicsRoutes } from './module-content/routes/topics-routes'
+import { apiRoutes as tenantRoutes } from './module-tenant/routes/tenant-routes'
+import { apiRoutes as merchantRoutes } from './module-merchant/routes/merchant-routes'
 
 const apiRateLimit = rateLimitMiddleware({
   windowMs: 60_000,
@@ -41,6 +43,7 @@ export const clientApiRoutes = new OpenAPIHono()
   .route('/api', cartRoutes)
   .route('/api', ordersMockRoutes)
   .route('/api', topicsRoutes)
+  .route('/api', merchantRoutes)
 
 // 管理后台路由 - 普通用户使用的 API + 管理功能
 export const adminApiRoutes = new OpenAPIHono()
@@ -56,6 +59,7 @@ export const adminApiRoutes = new OpenAPIHono()
   .route('/api', adminRoutes)
   .route('/api', pluginAdminRoutes)
   .route('/api', dashboardRoutes)
+  .route('/api', tenantRoutes)
 
 // 导出类型
 export type ClientApiRoutes = typeof clientApiRoutes

package/template/src/server/utils/__tests__/date.test.ts

@@ -0,0 +1,130 @@
+// @vitest-environment node
+import { describe, it, expect } from 'vitest'
+import {
+  toISOString,
+  formatDate,
+  parseDate,
+  getTimestamp,
+  transformDateField,
+  transformRole,
+  transformAuditLog,
+} from '../date'
+
+describe('date utils', () => {
+  describe('toISOString', () => {
+    it('should convert Date to ISO string', () => {
+      const date = new Date('2024-01-15T10:30:00.000Z')
+      expect(toISOString(date)).toBe('2024-01-15T10:30:00.000Z')
+    })
+  })
+
+  describe('formatDate', () => {
+    it('should format Date object', () => {
+      const date = new Date('2024-01-15T10:30:00.000Z')
+      expect(formatDate(date)).toBe('2024-01-15T10:30:00.000Z')
+    })
+
+    it('should format date string', () => {
+      const result = formatDate('2024-01-15')
+      expect(typeof result).toBe('string')
+      expect(new Date(result).getFullYear()).toBe(2024)
+    })
+
+    it('should format timestamp number', () => {
+      const ts = new Date('2024-01-15T10:30:00.000Z').getTime()
+      expect(formatDate(ts)).toBe('2024-01-15T10:30:00.000Z')
+    })
+  })
+
+  describe('parseDate', () => {
+    it('should parse date string to Date', () => {
+      const result = parseDate('2024-01-15T10:30:00.000Z')
+      expect(result).toBeInstanceOf(Date)
+      expect(result.toISOString()).toBe('2024-01-15T10:30:00.000Z')
+    })
+  })
+
+  describe('getTimestamp', () => {
+    it('should return current timestamp in milliseconds', () => {
+      const before = Date.now()
+      const result = getTimestamp()
+      const after = Date.now()
+      expect(result).toBeGreaterThanOrEqual(before)
+      expect(result).toBeLessThanOrEqual(after)
+      expect(typeof result).toBe('number')
+    })
+  })
+
+  describe('transformDateField', () => {
+    it('should convert Date to ISO string', () => {
+      const date = new Date('2024-01-15T00:00:00.000Z')
+      expect(transformDateField(date)).toBe('2024-01-15T00:00:00.000Z')
+    })
+
+    it('should return current time for null', () => {
+      const before = new Date().toISOString()
+      const result = transformDateField(null)
+      const after = new Date().toISOString()
+      expect(result >= before).toBe(true)
+      expect(result <= after).toBe(true)
+    })
+
+    it('should return current time for undefined', () => {
+      const before = new Date().toISOString()
+      const result = transformDateField(undefined)
+      const after = new Date().toISOString()
+      expect(result >= before).toBe(true)
+      expect(result <= after).toBe(true)
+    })
+  })
+
+  describe('transformRole', () => {
+    it('should transform role dates to strings', () => {
+      const role = {
+        id: 'role-1',
+        name: 'admin',
+        createdAt: new Date('2024-01-01T00:00:00.000Z'),
+        updatedAt: new Date('2024-06-01T00:00:00.000Z'),
+      }
+      const result = transformRole(role)
+      expect(result.id).toBe('role-1')
+      expect(result.name).toBe('admin')
+      expect(result.createdAt).toBe('2024-01-01T00:00:00.000Z')
+      expect(result.updatedAt).toBe('2024-06-01T00:00:00.000Z')
+    })
+
+    it('should handle null dates', () => {
+      const role = {
+        id: 'role-2',
+        name: 'user',
+        createdAt: null,
+        updatedAt: null,
+      }
+      const result = transformRole(role)
+      expect(result.id).toBe('role-2')
+      expect(typeof result.createdAt).toBe('string')
+      expect(typeof result.updatedAt).toBe('string')
+    })
+  })
+
+  describe('transformAuditLog', () => {
+    it('should transform audit log date to string', () => {
+      const log = {
+        id: 'log-1',
+        action: 'CREATE',
+        createdAt: new Date('2024-01-01T00:00:00.000Z'),
+      }
+      const result = transformAuditLog(log)
+      expect(result.id).toBe('log-1')
+      expect(result.action).toBe('CREATE')
+      expect(result.createdAt).toBe('2024-01-01T00:00:00.000Z')
+    })
+
+    it('should handle null createdAt', () => {
+      const log = { id: 'log-2', createdAt: null }
+      const result = transformAuditLog(log)
+      expect(result.id).toBe('log-2')
+      expect(typeof result.createdAt).toBe('string')
+    })
+  })
+})

package/template/src/server/utils/__tests__/env.test.ts

@@ -0,0 +1,25 @@
+// @vitest-environment node
+import { describe, it, expect } from 'vitest'
+import { isCloudflare, isNode } from '../env'
+
+describe('env', () => {
+  it('should export isCloudflare as boolean', () => {
+    expect(typeof isCloudflare).toBe('boolean')
+  })
+
+  it('should export isNode as boolean', () => {
+    expect(typeof isNode).toBe('boolean')
+  })
+
+  it('should detect Node environment', () => {
+    expect(isNode).toBe(true)
+  })
+
+  it('isCloudflare should be false in Node environment', () => {
+    expect(isCloudflare).toBe(false)
+  })
+
+  it('isCloudflare and isNode should be mutually exclusive', () => {
+    expect(isCloudflare && isNode).toBe(false)
+  })
+})

package/template/src/server/utils/__tests__/generate.test.ts

@@ -0,0 +1,82 @@
+// @vitest-environment node
+import { describe, it, expect } from 'vitest'
+import {
+  generateOrderNo,
+  generateTicketNo,
+  generateDisputeNo,
+  randomDate,
+  randomElement,
+} from '../generate'
+
+describe('generate', () => {
+  describe('generateOrderNo', () => {
+    it('should start with ORD prefix', () => {
+      expect(generateOrderNo()).toMatch(/^ORD/)
+    })
+
+    it('should generate unique values', () => {
+      expect(generateOrderNo()).not.toBe(generateOrderNo())
+    })
+
+    it('should have length greater than 10', () => {
+      expect(generateOrderNo().length).toBeGreaterThan(10)
+    })
+  })
+
+  describe('generateTicketNo', () => {
+    it('should start with TKT prefix', () => {
+      expect(generateTicketNo()).toMatch(/^TKT/)
+    })
+
+    it('should generate unique values', () => {
+      expect(generateTicketNo()).not.toBe(generateTicketNo())
+    })
+  })
+
+  describe('generateDisputeNo', () => {
+    it('should start with DSP prefix', () => {
+      expect(generateDisputeNo()).toMatch(/^DSP/)
+    })
+
+    it('should generate unique values', () => {
+      expect(generateDisputeNo()).not.toBe(generateDisputeNo())
+    })
+  })
+
+  describe('randomDate', () => {
+    it('should return ISO string between start and end', () => {
+      const start = new Date('2024-01-01T00:00:00.000Z')
+      const end = new Date('2024-12-31T23:59:59.999Z')
+      const result = randomDate(start, end)
+      const resultDate = new Date(result)
+      expect(resultDate.getTime()).toBeGreaterThanOrEqual(start.getTime())
+      expect(resultDate.getTime()).toBeLessThanOrEqual(end.getTime())
+    })
+
+    it('should return valid ISO string', () => {
+      const start = new Date('2020-01-01')
+      const end = new Date('2025-01-01')
+      const result = randomDate(start, end)
+      expect(result).toMatch(/^\d{4}-\d{2}-\d{2}T/)
+    })
+  })
+
+  describe('randomElement', () => {
+    it('should return element from array', () => {
+      const arr = [1, 2, 3, 4, 5]
+      const result = randomElement(arr)
+      expect(arr).toContain(result)
+    })
+
+    it('should handle single-element array', () => {
+      expect(randomElement([42])).toBe(42)
+    })
+
+    it('should return string from string array', () => {
+      const arr = ['a', 'b', 'c']
+      const result = randomElement(arr)
+      expect(typeof result).toBe('string')
+      expect(arr).toContain(result)
+    })
+  })
+})

package/template/src/server/utils/__tests__/id-helpers.test.ts

@@ -0,0 +1,29 @@
+// @vitest-environment node
+import { describe, it, expect } from 'vitest'
+import { parseModuleId } from '../id-helpers'
+
+describe('parseModuleId', () => {
+  it('should parse numeric id with prefix', () => {
+    expect(parseModuleId('order', 'order-123')).toBe(123)
+  })
+
+  it('should parse id with single digit', () => {
+    expect(parseModuleId('todo', 'todo-5')).toBe(5)
+  })
+
+  it('should return -1 for non-numeric id', () => {
+    expect(parseModuleId('order', 'order-abc')).toBe(-1)
+  })
+
+  it('should return -1 for missing prefix', () => {
+    expect(parseModuleId('order', 'ticket-123')).toBe(-1)
+  })
+
+  it('should handle zero id', () => {
+    expect(parseModuleId('test', 'test-0')).toBe(0)
+  })
+
+  it('should parse large numeric id', () => {
+    expect(parseModuleId('item', 'item-999999')).toBe(999999)
+  })
+})

package/template/src/server/utils/__tests__/json.test.ts

@@ -0,0 +1,49 @@
+// @vitest-environment node
+import { describe, it, expect } from 'vitest'
+import { parseJsonField, serializeJsonField } from '../json'
+
+describe('json utils', () => {
+  describe('parseJsonField', () => {
+    it('should parse valid JSON string', () => {
+      expect(parseJsonField<{ name: string }>('{"name":"test"}')).toEqual({ name: 'test' })
+    })
+
+    it('should return undefined for null', () => {
+      expect(parseJsonField(null)).toBeUndefined()
+    })
+
+    it('should return undefined for undefined', () => {
+      expect(parseJsonField(undefined)).toBeUndefined()
+    })
+
+    it('should return undefined for empty string', () => {
+      expect(parseJsonField('')).toBeUndefined()
+    })
+
+    it('should return undefined for invalid JSON', () => {
+      expect(parseJsonField('{invalid}')).toBeUndefined()
+    })
+
+    it('should parse array JSON', () => {
+      expect(parseJsonField<number[]>('[1,2,3]')).toEqual([1, 2, 3])
+    })
+  })
+
+  describe('serializeJsonField', () => {
+    it('should serialize object to JSON string', () => {
+      expect(serializeJsonField({ name: 'test' })).toBe('{"name":"test"}')
+    })
+
+    it('should return null for undefined', () => {
+      expect(serializeJsonField(undefined)).toBeNull()
+    })
+
+    it('should return null for null', () => {
+      expect(serializeJsonField(null)).toBeNull()
+    })
+
+    it('should serialize arrays', () => {
+      expect(serializeJsonField([1, 2, 3])).toBe('[1,2,3]')
+    })
+  })
+})

package/template/src/server/utils/__tests__/permission-utils.test.ts

@@ -0,0 +1,26 @@
+// @vitest-environment node
+import { describe, it, expect } from 'vitest'
+import { validatePermissions } from '../permission-utils'
+import { Permission } from '@shared/modules/permission'
+
+describe('validatePermissions', () => {
+  it('should return true for valid permissions', () => {
+    expect(validatePermissions([Permission.USER_VIEW, Permission.USER_CREATE])).toBe(true)
+  })
+
+  it('should return true for empty array', () => {
+    expect(validatePermissions([])).toBe(true)
+  })
+
+  it('should return false for invalid permission string', () => {
+    expect(validatePermissions(['invalid:permission' as Permission])).toBe(false)
+  })
+
+  it('should return false for mixed valid and invalid', () => {
+    expect(validatePermissions([Permission.USER_VIEW, 'invalid:permission' as Permission])).toBe(false)
+  })
+
+  it('should return true for single valid permission', () => {
+    expect(validatePermissions([Permission.ORDER_VIEW])).toBe(true)
+  })
+})

package/template/src/server/utils/__tests__/uuid.test.ts

@@ -0,0 +1,25 @@
+// @vitest-environment node
+import { describe, it, expect } from 'vitest'
+import { generateUUID } from '../uuid'
+
+describe('generateUUID', () => {
+  it('should return a string', () => {
+    expect(typeof generateUUID()).toBe('string')
+  })
+
+  it('should match UUID format', () => {
+    const uuid = generateUUID()
+    expect(uuid).toMatch(
+      /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{3,4}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,
+    )
+  })
+
+  it('should generate unique values', () => {
+    expect(generateUUID()).not.toBe(generateUUID())
+  })
+
+  it('should generate 100 unique values', () => {
+    const uuids = new Set(Array.from({ length: 100 }, () => generateUUID()))
+    expect(uuids.size).toBe(100)
+  })
+})

package/template/src/shared/core/module-manifest.ts

@@ -76,6 +76,13 @@ export interface ModuleManifest {
     files: string[]
     /** Whether the module has seed data */
     hasSeed: boolean
+    /** Seed function info (required when hasSeed is true) */
+    seed?: {
+      /** Service file name under module-xxx/services/ (e.g., 'todo-service') */
+      serviceFile: string
+      /** Seed function name (e.g., 'seedTodosIfEmpty') */
+      functionName: string
+    }
   }
 
   /** Required npm dependencies (beyond what core provides) */
@@ -99,6 +106,14 @@ export interface ModuleManifest {
 
   /** Whether this module has WebSocket routes */
   hasWebSocket?: boolean
+
+  /** CLI module mapping — links server module to its CLI command module */
+  cliModule?: {
+    /** CLI module directory name under src/cli/modules/ (e.g., 'todo') */
+    dir: string
+    /** Register function name (e.g., 'registerTodoCommands') */
+    registerFunction: string
+  }
 }
 
 /** Type-safe module registry — maps module name to its manifest */

package/template/src/shared/modules/admin/schemas.ts

@@ -79,7 +79,7 @@ export const ClearTodosResultSchema = z.object({
   deletedCount: z.number(),
 })
 
-export const SuccessSchema = z.object({})
+export const AdminSuccessSchema = z.object({})
 
 export const DownloadTokenSchema = z.object({
   token: z.string(),