create-fullstack-scaffold 0.1.0

package/template/src/server/module-order/__tests__/order-route.test.ts

@@ -0,0 +1,258 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest'
+import { createTestClient } from '@server/test-utils/test-client'
+import { setupTestDatabase, cleanupTestDatabase } from '@server/db/test-setup'
+
+describe('Order Routes', () => {
+  const authHeaders = { Authorization: 'Bearer admin-token' }
+
+  beforeAll(async () => {
+    await setupTestDatabase()
+  })
+
+  afterAll(async () => {
+    await cleanupTestDatabase()
+  })
+
+  describe('GET /api/orders', () => {
+    it('should return list of orders', async () => {
+      const client = createTestClient(undefined, { headers: authHeaders })
+      const res = await client.api['orders'].$get({ query: {} })
+      expect(res.status).toBe(200)
+
+      const data = await res.json()
+      expect(data.success).toBe(true)
+      if (data.success) {
+        expect(Array.isArray(data.data)).toBe(true)
+      }
+    })
+
+    it('should filter orders by status', async () => {
+      const client = createTestClient(undefined, { headers: authHeaders })
+
+      const res = await client.api['orders'].$get({
+        query: { status: 'completed' },
+      })
+      expect(res.status).toBe(200)
+
+      const data = await res.json()
+      expect(data.success).toBe(true)
+      if (data.success) {
+        expect(Array.isArray(data.data)).toBe(true)
+        data.data.forEach((order: { status: string }) => {
+          expect(order.status).toBe('completed')
+        })
+      }
+    })
+
+    it('should filter orders by customerName', async () => {
+      const client = createTestClient(undefined, { headers: authHeaders })
+
+      const res = await client.api['orders'].$get({
+        query: { customerName: '张三' },
+      })
+      expect(res.status).toBe(200)
+
+      const data = await res.json()
+      expect(data.success).toBe(true)
+      if (data.success) {
+        expect(Array.isArray(data.data)).toBe(true)
+        data.data.forEach((order: { customerName: string }) => {
+          expect(order.customerName).toContain('张三')
+        })
+      }
+    })
+
+    it('should filter orders by both status and customerName', async () => {
+      const client = createTestClient(undefined, { headers: authHeaders })
+
+      const res = await client.api['orders'].$get({
+        query: { status: 'pending', customerName: '李四' },
+      })
+      expect(res.status).toBe(200)
+
+      const data = await res.json()
+      expect(data.success).toBe(true)
+      if (data.success) {
+        expect(Array.isArray(data.data)).toBe(true)
+        data.data.forEach((order: { status: string; customerName: string }) => {
+          expect(order.status).toBe('pending')
+          expect(order.customerName).toContain('李四')
+        })
+      }
+    })
+
+    it('should return empty array when no orders match filter', async () => {
+      const client = createTestClient(undefined, { headers: authHeaders })
+
+      const res = await client.api['orders'].$get({
+        query: { customerName: 'NonExistentCustomer12345' },
+      })
+      expect(res.status).toBe(200)
+
+      const data = await res.json()
+      expect(data.success).toBe(true)
+      if (data.success) {
+        expect(data.data).toHaveLength(0)
+      }
+    })
+  })
+
+  describe('GET /api/orders/:id', () => {
+    it('should fetch order by id', async () => {
+      const client = createTestClient(undefined, { headers: authHeaders })
+
+      const createRes = await client.api['orders'].$post({
+        json: {
+          customerName: 'Fetch Test',
+          customerEmail: 'fetch@example.com',
+          productName: 'Fetch Product',
+          amount: 100,
+        },
+      })
+      const createData = await createRes.json()
+      const orderId = createData.success ? createData.data.id : ''
+
+      const res = await client.api['orders'][':id'].$get({
+        param: { id: orderId },
+      })
+      expect(res.status).toBe(200)
+
+      const data = await res.json()
+      expect(data.success).toBe(true)
+      if (data.success) {
+        expect(data.data.id).toBe(orderId)
+      }
+    })
+
+    it('should return 404 for non-existent order', async () => {
+      const client = createTestClient(undefined, { headers: authHeaders })
+      const res = await client.api['orders'][':id'].$get({
+        param: { id: 'non-existent' },
+      })
+      expect(res.status).toBe(404)
+    })
+  })
+
+  describe('POST /api/orders', () => {
+    it('should create a new order', async () => {
+      const client = createTestClient(undefined, { headers: authHeaders })
+      const res = await client.api['orders'].$post({
+        json: {
+          customerName: 'Test Customer',
+          customerEmail: 'test@example.com',
+          productName: 'Test Product',
+          amount: 200,
+        },
+      })
+      expect(res.status).toBe(201)
+
+      const data = await res.json()
+      expect(data.success).toBe(true)
+      if (data.success) {
+        expect(data.data.id).toBeDefined()
+        expect(data.data.amount).toBe(200)
+      }
+    })
+  })
+
+  describe('PUT /api/orders/:id', () => {
+    it('should update an order status', async () => {
+      const client = createTestClient(undefined, { headers: authHeaders })
+
+      const createRes = await client.api['orders'].$post({
+        json: {
+          customerName: 'Update Test',
+          customerEmail: 'update@example.com',
+          productName: 'Update Product',
+          amount: 50,
+        },
+      })
+      const createData = await createRes.json()
+      const orderId = createData.success ? createData.data.id : ''
+
+      const res = await client.api['orders'][':id'].$put({
+        param: { id: orderId },
+        json: { status: 'processing' },
+      })
+      expect(res.status).toBe(200)
+
+      const data = await res.json()
+      expect(data.success).toBe(true)
+    })
+  })
+
+  describe('DELETE /api/orders/:id', () => {
+    it('should delete an order', async () => {
+      const client = createTestClient(undefined, { headers: authHeaders })
+
+      const createRes = await client.api['orders'].$post({
+        json: {
+          customerName: 'Delete Test',
+          customerEmail: 'delete@example.com',
+          productName: 'Delete Product',
+          amount: 50,
+        },
+      })
+      const createData = await createRes.json()
+      const orderId = createData.success ? createData.data.id : ''
+
+      const res = await client.api['orders'][':id'].$delete({
+        param: { id: orderId },
+      })
+      expect(res.status).toBe(200)
+
+      const data = await res.json()
+      expect(data.success).toBe(true)
+    })
+  })
+
+  describe('PUT /api/orders/:id/process', () => {
+    it('should process an order', async () => {
+      const client = createTestClient(undefined, { headers: authHeaders })
+
+      const createRes = await client.api['orders'].$post({
+        json: {
+          customerName: 'Process Test',
+          customerEmail: 'process@example.com',
+          productName: 'Process Product',
+          amount: 50,
+        },
+      })
+      const createData = await createRes.json()
+      const orderId = createData.success ? createData.data.id : ''
+
+      const res = await client.api['orders'][':id'].process.$put({
+        param: { id: orderId },
+      })
+      expect(res.status).toBe(200)
+
+      const data = await res.json()
+      expect(data.success).toBe(true)
+    })
+  })
+
+  describe('PUT /api/orders/:id/cancel', () => {
+    it('should cancel an order', async () => {
+      const client = createTestClient(undefined, { headers: authHeaders })
+
+      const createRes = await client.api['orders'].$post({
+        json: {
+          customerName: 'Cancel Test',
+          customerEmail: 'cancel@example.com',
+          productName: 'Cancel Product',
+          amount: 50,
+        },
+      })
+      const createData = await createRes.json()
+      const orderId = createData.success ? createData.data.id : ''
+
+      const res = await client.api['orders'][':id'].cancel.$put({
+        param: { id: orderId },
+      })
+      expect(res.status).toBe(200)
+
+      const data = await res.json()
+      expect(data.success).toBe(true)
+    })
+  })
+})

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

@@ -0,0 +1,222 @@
+import { describe, it, expect, beforeEach, beforeAll, afterAll } from 'vitest'
+import * as service from '../services/order-service'
+import type { CreateOrderInput, UpdateOrderInput } from '@shared/modules/order'
+import { setupTestDatabase, cleanupTestDatabase } from '@server/db/test-setup'
+
+describe('Order Service', () => {
+  let createdOrderIds: string[] = []
+
+  beforeAll(async () => {
+    await setupTestDatabase()
+  })
+
+  afterAll(async () => {
+    await cleanupTestDatabase()
+  })
+
+  beforeEach(() => {
+    createdOrderIds = []
+  })
+
+  describe('getOrders', () => {
+    it('should return all orders when no filters provided', async () => {
+      const result = await service.getOrders()
+      expect(Array.isArray(result)).toBe(true)
+    })
+
+    it('should filter orders by status', async () => {
+      const data: CreateOrderInput = {
+        customerName: 'Filter Test',
+        customerEmail: 'filter@example.com',
+        productName: 'Filter Product',
+        amount: 100,
+      }
+      const created = await service.createOrder(data)
+      createdOrderIds.push(created.id)
+
+      await service.updateOrder(created.id, { status: 'processing' })
+
+      const result = await service.getOrders({ status: 'processing' })
+      expect(Array.isArray(result)).toBe(true)
+      result.forEach(order => {
+        expect(order.status).toBe('processing')
+      })
+    })
+  })
+
+  describe('getOrderById', () => {
+    it('should return order when id exists', async () => {
+      const data: CreateOrderInput = {
+        customerName: 'Get Test',
+        customerEmail: 'get@example.com',
+        productName: 'Get Product',
+        amount: 100,
+      }
+      const created = await service.createOrder(data)
+      createdOrderIds.push(created.id)
+
+      const result = await service.getOrderById(created.id)
+      expect(result).not.toBeNull()
+      expect(result?.id).toBe(created.id)
+    })
+
+    it('should return null for non-existent order id', async () => {
+      const result = await service.getOrderById('order-999999')
+      expect(result).toBeNull()
+    })
+  })
+
+  describe('createOrder', () => {
+    it('should create a new order with correct data', async () => {
+      const data: CreateOrderInput = {
+        customerName: 'Test Customer',
+        customerEmail: 'test@example.com',
+        productName: 'Test Product',
+        amount: 100,
+      }
+      const result = await service.createOrder(data)
+      createdOrderIds.push(result.id)
+
+      expect(result).toMatchObject({
+        customerName: 'Test Customer',
+        customerEmail: 'test@example.com',
+        productName: 'Test Product',
+        amount: 100,
+        status: 'pending',
+      })
+      expect(result.id).toBeDefined()
+    })
+  })
+
+  describe('updateOrder', () => {
+    it('should update existing order status', async () => {
+      const data: CreateOrderInput = {
+        customerName: 'Update Test',
+        customerEmail: 'update@example.com',
+        productName: 'Update Product',
+        amount: 200,
+      }
+      const created = await service.createOrder(data)
+      createdOrderIds.push(created.id)
+
+      const updateData: UpdateOrderInput = {
+        status: 'processing',
+      }
+      const result = await service.updateOrder(created.id, updateData)
+
+      expect(result).not.toBeNull()
+      expect(result?.status).toBe('processing')
+    })
+
+    it('should return null when updating non-existent order', async () => {
+      const result = await service.updateOrder('order-999999', { status: 'completed' })
+      expect(result).toBeNull()
+    })
+  })
+
+  describe('deleteOrder', () => {
+    it('should delete existing order successfully', async () => {
+      const data: CreateOrderInput = {
+        customerName: 'Delete Test',
+        customerEmail: 'delete@example.com',
+        productName: 'Delete Product',
+        amount: 100,
+      }
+      const created = await service.createOrder(data)
+
+      const result = await service.deleteOrder(created.id)
+      expect(result.message).toBe('订单已删除')
+
+      const found = await service.getOrderById(created.id)
+      expect(found).toBeNull()
+    })
+
+    it('should return failure when deleting non-existent order', async () => {
+      const result = await service.deleteOrder('order-999999')
+      expect(result.message).toBe('订单不存在')
+    })
+  })
+
+  describe('processOrder', () => {
+    it('should process a pending order', async () => {
+      const data: CreateOrderInput = {
+        customerName: 'Process Test',
+        customerEmail: 'process@example.com',
+        productName: 'Process Product',
+        amount: 150,
+      }
+      const created = await service.createOrder(data)
+      createdOrderIds.push(created.id)
+
+      const result = await service.processOrder(created.id)
+      expect(result).not.toBeNull()
+      expect(result?.status).toBe('processing')
+    })
+
+    it('should return null when processing non-existent order', async () => {
+      const result = await service.processOrder('order-999999')
+      expect(result).toBeNull()
+    })
+  })
+
+  describe('cancelOrder', () => {
+    it('should cancel a pending order', async () => {
+      const data: CreateOrderInput = {
+        customerName: 'Cancel Test',
+        customerEmail: 'cancel@example.com',
+        productName: 'Cancel Product',
+        amount: 200,
+      }
+      const created = await service.createOrder(data)
+      createdOrderIds.push(created.id)
+
+      const result = await service.cancelOrder(created.id)
+      expect(result).not.toBeNull()
+      expect(result?.status).toBe('cancelled')
+    })
+
+    it('should return null when cancelling non-existent order', async () => {
+      const result = await service.cancelOrder('order-999999')
+      expect(result).toBeNull()
+    })
+  })
+
+  describe('completeOrder', () => {
+    it('should complete a processing order', async () => {
+      const data: CreateOrderInput = {
+        customerName: 'Complete Test',
+        customerEmail: 'complete@example.com',
+        productName: 'Complete Product',
+        amount: 300,
+      }
+      const created = await service.createOrder(data)
+      createdOrderIds.push(created.id)
+
+      const processed = await service.processOrder(created.id)
+      expect(processed).not.toBeNull()
+      expect(processed?.status).toBe('processing')
+
+      const result = await service.completeOrder(created.id)
+      expect(result).not.toBeNull()
+      expect(result?.status).toBe('completed')
+    })
+
+    it('should return null when completing non-existent order', async () => {
+      const result = await service.completeOrder('order-999999')
+      expect(result).toBeNull()
+    })
+
+    it('should return null when completing pending order (not processing)', async () => {
+      const data: CreateOrderInput = {
+        customerName: 'Complete Pending Test',
+        customerEmail: 'complete-pending@example.com',
+        productName: 'Complete Pending Product',
+        amount: 400,
+      }
+      const created = await service.createOrder(data)
+      createdOrderIds.push(created.id)
+      const result = await service.completeOrder(created.id)
+      expect(result).toBeNull()
+    })
+  })
+})

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

@@ -0,0 +1,30 @@
+import type { ModuleManifest } from '@shared/core/module-manifest'
+
+const orderManifest: ModuleManifest = {
+  name: 'order',
+  description: 'Order management with process/cancel/complete workflow',
+  category: 'business',
+  dependsOn: ['permission'],
+
+  routes: {
+    admin: [
+      {
+        importPath: './routes/order-routes',
+        exportName: 'orderRoutes',
+      },
+    ],
+  },
+
+  sharedSchemas: {
+    path: 'order',
+  },
+
+  adminPages: [{ name: 'OrdersPage', route: '/orders', requiredPermission: 'ORDER_VIEW' }],
+
+  dbSchemas: {
+    files: ['orders'],
+    hasSeed: true,
+  },
+}
+
+export default orderManifest