136 lines
4.5 KiB
TypeScript
136 lines
4.5 KiB
TypeScript
import { Router, type Router as RouterType } from 'express';
|
|
import { z } from 'zod';
|
|
import { prisma } from '@agent-fox/shared';
|
|
import { requireAuth } from '../middleware/auth.js';
|
|
import { parseOpenApiDocument } from '../services/openapi-parser.js';
|
|
|
|
const router: RouterType = Router();
|
|
router.use(requireAuth);
|
|
|
|
router.post('/', async (req, res) => {
|
|
const { spec, specUrl } = req.body;
|
|
if (!spec && !specUrl) {
|
|
res.status(400).json({ success: false, error: { code: 'VALIDATION', message: 'Provide spec (JSON object) or specUrl (URL string)' } });
|
|
return;
|
|
}
|
|
|
|
try {
|
|
const input = specUrl || spec;
|
|
const parsed = await parseOpenApiDocument(input);
|
|
|
|
const project = await prisma.$transaction(async (tx) => {
|
|
const proj = await tx.project.create({
|
|
data: {
|
|
userId: req.user!.userId,
|
|
name: parsed.name,
|
|
description: parsed.description,
|
|
baseUrl: parsed.baseUrl,
|
|
openApiSpec: parsed.spec as any,
|
|
openApiVersion: parsed.openApiVersion,
|
|
},
|
|
});
|
|
|
|
const moduleIdMap = new Map<string, string>();
|
|
for (let i = 0; i < parsed.modules.length; i++) {
|
|
const mod = parsed.modules[i];
|
|
const created = await tx.module.create({
|
|
data: {
|
|
projectId: proj.id, name: mod.name, description: mod.description,
|
|
sortOrder: i, source: mod.source,
|
|
},
|
|
});
|
|
moduleIdMap.set(mod.name, created.id);
|
|
}
|
|
|
|
for (const ep of parsed.endpoints) {
|
|
const moduleId = moduleIdMap.get(ep.moduleName);
|
|
if (!moduleId) continue;
|
|
await tx.endpoint.create({
|
|
data: {
|
|
projectId: proj.id, moduleId, method: ep.method, path: ep.path,
|
|
summary: ep.summary, description: ep.description, operationId: ep.operationId,
|
|
parameters: ep.parameters as any, requestBody: ep.requestBody as any,
|
|
responses: ep.responses as any, tags: ep.tags, deprecated: ep.deprecated,
|
|
},
|
|
});
|
|
}
|
|
return proj;
|
|
});
|
|
|
|
res.status(201).json({
|
|
success: true,
|
|
data: {
|
|
project: { id: project.id, name: project.name },
|
|
stats: { modules: parsed.modules.length, endpoints: parsed.endpoints.length },
|
|
},
|
|
});
|
|
} catch (err) {
|
|
const message = err instanceof Error ? err.message : 'Failed to parse OpenAPI document';
|
|
res.status(400).json({ success: false, error: { code: 'PARSE_ERROR', message } });
|
|
}
|
|
});
|
|
|
|
router.get('/', async (req, res) => {
|
|
const projects = await prisma.project.findMany({
|
|
where: { userId: req.user!.userId },
|
|
include: { _count: { select: { endpoints: true, modules: true } } },
|
|
orderBy: { updatedAt: 'desc' },
|
|
});
|
|
res.json({ success: true, data: projects });
|
|
});
|
|
|
|
router.get('/:id', async (req, res) => {
|
|
const project = await prisma.project.findFirst({
|
|
where: { id: req.params.id, userId: req.user!.userId },
|
|
include: {
|
|
modules: {
|
|
include: { _count: { select: { endpoints: true } } },
|
|
orderBy: { sortOrder: 'asc' },
|
|
},
|
|
_count: { select: { endpoints: true } },
|
|
},
|
|
});
|
|
if (!project) {
|
|
res.status(404).json({ success: false, error: { code: 'NOT_FOUND', message: 'Project not found' } });
|
|
return;
|
|
}
|
|
res.json({ success: true, data: project });
|
|
});
|
|
|
|
const updateSchema = z.object({
|
|
name: z.string().min(1).max(200).optional(),
|
|
description: z.string().max(1000).optional(),
|
|
baseUrl: z.string().url().optional(),
|
|
});
|
|
|
|
router.put('/:id', async (req, res) => {
|
|
const parsed = updateSchema.safeParse(req.body);
|
|
if (!parsed.success) {
|
|
res.status(400).json({ success: false, error: { code: 'VALIDATION', message: parsed.error.issues[0].message } });
|
|
return;
|
|
}
|
|
const project = await prisma.project.updateMany({
|
|
where: { id: req.params.id, userId: req.user!.userId },
|
|
data: parsed.data,
|
|
});
|
|
if (project.count === 0) {
|
|
res.status(404).json({ success: false, error: { code: 'NOT_FOUND', message: 'Project not found' } });
|
|
return;
|
|
}
|
|
const updated = await prisma.project.findUnique({ where: { id: req.params.id } });
|
|
res.json({ success: true, data: updated });
|
|
});
|
|
|
|
router.delete('/:id', async (req, res) => {
|
|
const result = await prisma.project.deleteMany({
|
|
where: { id: req.params.id, userId: req.user!.userId },
|
|
});
|
|
if (result.count === 0) {
|
|
res.status(404).json({ success: false, error: { code: 'NOT_FOUND', message: 'Project not found' } });
|
|
return;
|
|
}
|
|
res.json({ success: true, data: { deleted: true } });
|
|
});
|
|
|
|
export default router;
|