feat(engine): add CRUD endpoints for SVS engine

apps/backend/src/handlers/catalog/engine/create.ts

@@ -0,0 +1,33 @@
+import { Elysia } from "elysia";
+import {
+	CreateEngineRequestSchema,
+	ErrorResponseSchema,
+	EngineResponseSchema,
+	engineService,
+} from "@cvsa/core";
+import { authMiddleware } from "@/middlewares";
+import { traceTask } from "@/common/trace";
+
+export const engineCreateHandler = new Elysia({ name: "engineCreateHandler" })
+	.use(authMiddleware)
+	.post(
+		"/engine",
+		async ({ body, status }) => {
+			const engine = await traceTask("engineService.create", async () => {
+				return await engineService.create(body);
+			});
+			return status(201, engine);
+		},
+		{
+			body: CreateEngineRequestSchema,
+			detail: {
+				summary: "Create Engine",
+				description:
+					"Create a new SVS engine entry in the catalog. Requires authentication.",
+			},
+			response: {
+				201: EngineResponseSchema,
+				401: ErrorResponseSchema,
+			},
+		}
+	);

apps/backend/src/handlers/catalog/engine/delete.ts

@@ -0,0 +1,34 @@
+import { Elysia } from "elysia";
+import { z } from "zod";
+import { ErrorResponseSchema, engineService } from "@cvsa/core";
+import { authMiddleware } from "@/middlewares";
+import { traceTask } from "@/common/trace";
+
+export const engineDeleteHandler = new Elysia({ name: "engineDeleteHandler" })
+	.use(authMiddleware)
+	.delete(
+		"/engine/:id",
+		async ({ params, set }) => {
+			await traceTask("engineService.delete", async () => {
+				return await engineService.delete(params.id);
+			});
+			set.status = 204;
+			return null;
+		},
+		{
+			params: z.object({
+				id: z.coerce.number().int().positive(),
+			}),
+			detail: {
+				summary: "Delete Engine",
+				description:
+					"Soft delete an SVS engine from the catalog. Requires authentication. The engine record is marked as deleted but retained in the database for data integrity.",
+			},
+			response: {
+				204: z.null(),
+				400: ErrorResponseSchema,
+				401: ErrorResponseSchema,
+				404: ErrorResponseSchema,
+			},
+		}
+	);

apps/backend/src/handlers/catalog/engine/details.ts

@@ -0,0 +1,29 @@
+import { Elysia } from "elysia";
+import { ErrorResponseSchema, EngineDetailsResponseSchema, engineService } from "@cvsa/core";
+import z from "zod";
+import { traceTask } from "@/common/trace";
+
+export const engineDetailsHandler = new Elysia().get(
+	"/engine/:id/details",
+	async ({ params, status }) => {
+		const engine = await traceTask("engineService.getDetails", async () => {
+			return await engineService.getDetails(params.id);
+		});
+		return status(200, engine);
+	},
+	{
+		detail: {
+			summary: "Engine Details",
+			description:
+				"Retrieve detailed information about a specific SVS engine by its ID. Includes name, description, and metadata.",
+		},
+		response: {
+			200: EngineDetailsResponseSchema,
+			400: ErrorResponseSchema,
+			404: ErrorResponseSchema,
+		},
+		params: z.object({
+			id: z.coerce.number().int().positive(),
+		}),
+	}
+);

apps/backend/src/handlers/catalog/engine/index.ts

@@ -0,0 +1,11 @@
+import { Elysia } from "elysia";
+import { engineCreateHandler } from "./create";
+import { engineUpdateHandler } from "./update";
+import { engineDeleteHandler } from "./delete";
+import { engineDetailsHandler } from "./details";
+
+export const engineHandler = new Elysia({ name: "engineHandler" })
+	.use(engineDetailsHandler)
+	.use(engineCreateHandler)
+	.use(engineUpdateHandler)
+	.use(engineDeleteHandler);

apps/backend/src/handlers/catalog/engine/update.ts

@@ -0,0 +1,39 @@
+import { Elysia } from "elysia";
+import { z } from "zod";
+import {
+	UpdateEngineRequestSchema,
+	ErrorResponseSchema,
+	engineService,
+	EngineResponseSchema,
+} from "@cvsa/core";
+import { authMiddleware } from "@/middlewares";
+import { traceTask } from "@/common/trace";
+
+export const engineUpdateHandler = new Elysia({ name: "engineUpdateHandler" })
+	.use(authMiddleware)
+	.patch(
+		"/engine/:id",
+		async ({ params, body, status }) => {
+			const engine = await traceTask("engineService.update", async () => {
+				return await engineService.update(params.id, body);
+			});
+			return status(200, engine);
+		},
+		{
+			body: UpdateEngineRequestSchema,
+			params: z.object({
+				id: z.coerce.number().int().positive(),
+			}),
+			detail: {
+				summary: "Update Engine",
+				description:
+					"Update metadata of an existing SVS engine identified by its ID. Requires authentication.",
+			},
+			response: {
+				200: EngineResponseSchema,
+				400: ErrorResponseSchema,
+				401: ErrorResponseSchema,
+				404: ErrorResponseSchema,
+			},
+		}
+	);

apps/backend/src/handlers/index.ts

@@ -1,3 +1,4 @@
 export * from "./auth";
 export * from "./catalog/song";
+export * from "./catalog/engine";
 export * from "./dev";

apps/backend/src/index.ts

@@ -2,7 +2,7 @@ import { Elysia } from "elysia";
 import { onAfterHandler } from "./onAfterHandle";
 import { getBindingInfo, logStartup } from "./startMessage";
 import pkg from "../package.json";
-import { authHandler, songHandler } from "@handlers/index";
+import { authHandler, songHandler, engineHandler } from "@handlers/index";
 import { errorHandler } from "./errorHandler";
 import { openapi } from "@elysiajs/openapi";
 import { requestLoggerMiddleware } from "@/middlewares";
@@ -32,6 +32,7 @@ export const app = new Elysia({
 	.use(openapi())
 	.use(authHandler)
 	.use(songHandler)
+	.use(engineHandler)
 	.use(devHandler)
 	.listen(16412);