完成流水线控制器重构和相关功能改进

This commit is contained in:
2025-11-21 23:30:05 +08:00
parent fd0cf782c4
commit f8697b87e1
33 changed files with 1262 additions and 538 deletions

View File

@@ -0,0 +1,234 @@
import type { Context } from 'koa';
import prisma from '../../libs/db.ts';
import { log } from '../../libs/logger.ts';
import { BusinessError } from '../../middlewares/exception.ts';
import { Controller, Get, Post, Put, Delete } from '../../decorators/route.ts';
import { z } from 'zod';
// 定义验证架构
const createStepSchema = z.object({
name: z.string({
message: '步骤名称必须是字符串',
}).min(1, { message: '步骤名称不能为空' }).max(100, { message: '步骤名称不能超过100个字符' }),
description: z.string({
message: '步骤描述必须是字符串',
}).max(500, { message: '步骤描述不能超过500个字符' }).optional(),
order: z.number({
message: '步骤顺序必须是数字',
}).int().min(0, { message: '步骤顺序必须是非负整数' }),
script: z.string({
message: '脚本命令必须是字符串',
}).min(1, { message: '脚本命令不能为空' }),
pipelineId: z.number({
message: '流水线ID必须是数字',
}).int().positive({ message: '流水线ID必须是正整数' }),
});
const updateStepSchema = z.object({
name: z.string({
message: '步骤名称必须是字符串',
}).min(1, { message: '步骤名称不能为空' }).max(100, { message: '步骤名称不能超过100个字符' }).optional(),
description: z.string({
message: '步骤描述必须是字符串',
}).max(500, { message: '步骤描述不能超过500个字符' }).optional(),
order: z.number({
message: '步骤顺序必须是数字',
}).int().min(0, { message: '步骤顺序必须是非负整数' }).optional(),
script: z.string({
message: '脚本命令必须是字符串',
}).min(1, { message: '脚本命令不能为空' }).optional(),
});
const stepIdSchema = z.object({
id: z.coerce.number().int().positive({ message: '步骤 ID 必须是正整数' }),
});
const listStepsQuerySchema = z.object({
pipelineId: z.coerce.number().int().positive({ message: '流水线ID必须是正整数' }).optional(),
page: z.coerce.number().int().min(1, { message: '页码必须大于0' }).optional().default(1),
limit: z.coerce.number().int().min(1, { message: '每页数量必须大于0' }).max(100, { message: '每页数量不能超过100' }).optional().default(10),
}).optional();
// TypeScript 类型
type CreateStepInput = z.infer<typeof createStepSchema>;
type UpdateStepInput = z.infer<typeof updateStepSchema>;
type StepIdParams = z.infer<typeof stepIdSchema>;
type ListStepsQuery = z.infer<typeof listStepsQuerySchema>;
@Controller('/steps')
export class StepController {
// GET /api/steps - 获取步骤列表
@Get('')
async list(ctx: Context) {
const query = listStepsQuerySchema.parse(ctx.query);
const whereCondition: any = {
valid: 1,
};
// 如果提供了流水线ID参数
if (query?.pipelineId) {
whereCondition.pipelineId = query.pipelineId;
}
const [total, steps] = await Promise.all([
prisma.step.count({ where: whereCondition }),
prisma.step.findMany({
where: whereCondition,
skip: query ? (query.page - 1) * query.limit : 0,
take: query?.limit,
orderBy: {
order: 'asc',
},
})
]);
return {
data: steps,
pagination: {
page: query?.page || 1,
limit: query?.limit || 10,
total,
totalPages: Math.ceil(total / (query?.limit || 10)),
}
};
}
// GET /api/steps/:id - 获取单个步骤
@Get(':id')
async show(ctx: Context) {
const { id } = stepIdSchema.parse(ctx.params);
const step = await prisma.step.findFirst({
where: {
id,
valid: 1,
},
});
if (!step) {
throw new BusinessError('步骤不存在', 2001, 404);
}
return step;
}
// POST /api/steps - 创建步骤
@Post('')
async create(ctx: Context) {
const validatedData = createStepSchema.parse(ctx.request.body);
// 检查关联的流水线是否存在
const pipeline = await prisma.pipeline.findFirst({
where: {
id: validatedData.pipelineId,
valid: 1,
},
});
if (!pipeline) {
throw new BusinessError('关联的流水线不存在', 2002, 404);
}
const step = await prisma.step.create({
data: {
name: validatedData.name,
description: validatedData.description || '',
order: validatedData.order,
script: validatedData.script,
pipelineId: validatedData.pipelineId,
createdBy: 'system',
updatedBy: 'system',
valid: 1,
},
});
log.info('step', 'Created new step: %s', step.name);
return step;
}
// PUT /api/steps/:id - 更新步骤
@Put(':id')
async update(ctx: Context) {
const { id } = stepIdSchema.parse(ctx.params);
const validatedData = updateStepSchema.parse(ctx.request.body);
// 检查步骤是否存在
const existingStep = await prisma.step.findFirst({
where: {
id,
valid: 1,
},
});
if (!existingStep) {
throw new BusinessError('步骤不存在', 2001, 404);
}
// 只更新提供的字段
const updateData: any = {
updatedBy: 'system',
};
if (validatedData.name !== undefined) {
updateData.name = validatedData.name;
}
if (validatedData.description !== undefined) {
updateData.description = validatedData.description;
}
if (validatedData.order !== undefined) {
updateData.order = validatedData.order;
}
if (validatedData.script !== undefined) {
updateData.script = validatedData.script;
}
const step = await prisma.step.update({
where: { id },
data: updateData,
});
log.info('step', 'Updated step: %s', step.name);
return step;
}
// DELETE /api/steps/:id - 删除步骤(软删除)
@Delete(':id')
async destroy(ctx: Context) {
const { id } = stepIdSchema.parse(ctx.params);
// 检查步骤是否存在
const existingStep = await prisma.step.findFirst({
where: {
id,
valid: 1,
},
});
if (!existingStep) {
throw new BusinessError('步骤不存在', 2001, 404);
}
// 软删除:将 valid 设置为 0
await prisma.step.update({
where: { id },
data: {
valid: 0,
updatedBy: 'system',
},
});
log.info('step', 'Deleted step: %s', existingStep.name);
// RESTful 删除成功返回 204 No Content
ctx.status = 204;
return null;
}
}