refactor(api): extract management level support

2026-03-31 13:52:24 +02:00
parent 6f69021fe5
commit b920fa271d
3 changed files with 189 additions and 38 deletions
@@ -0,0 +1,100 @@
+import type { Prisma, PrismaClient } from "@capakraken/db";
+import {
+  CreateManagementLevelGroupSchema,
+  CreateManagementLevelSchema,
+  UpdateManagementLevelGroupSchema,
+  UpdateManagementLevelSchema,
+} from "@capakraken/shared";
+import { TRPCError } from "@trpc/server";
+import { z } from "zod";
+
+type ManagementLevelGroupDb = Pick<PrismaClient, "managementLevelGroup">;
+type ManagementLevelDb = Pick<PrismaClient, "managementLevel">;
+
+type ManagementLevelDeleteRecord = {
+  _count: {
+    resources: number;
+  };
+};
+
+type CreateManagementLevelGroupInput = z.infer<typeof CreateManagementLevelGroupSchema>;
+type UpdateManagementLevelGroupInput = z.infer<typeof UpdateManagementLevelGroupSchema>;
+type CreateManagementLevelInput = z.infer<typeof CreateManagementLevelSchema>;
+type UpdateManagementLevelInput = z.infer<typeof UpdateManagementLevelSchema>;
+
+export async function assertManagementLevelGroupNameAvailable(
+  db: ManagementLevelGroupDb,
+  name: string,
+  ignoreId?: string,
+): Promise<void> {
+  const existing = await db.managementLevelGroup.findUnique({ where: { name } });
+  if (existing && existing.id !== ignoreId) {
+    throw new TRPCError({
+      code: "CONFLICT",
+      message: `Group "${name}" already exists`,
+    });
+  }
+}
+
+export async function assertManagementLevelNameAvailable(
+  db: ManagementLevelDb,
+  name: string,
+  ignoreId?: string,
+): Promise<void> {
+  const existing = await db.managementLevel.findUnique({ where: { name } });
+  if (existing && existing.id !== ignoreId) {
+    throw new TRPCError({
+      code: "CONFLICT",
+      message: `Level "${name}" already exists`,
+    });
+  }
+}
+
+export function buildManagementLevelGroupCreateData(
+  input: CreateManagementLevelGroupInput,
+): Prisma.ManagementLevelGroupUncheckedCreateInput {
+  return {
+    name: input.name,
+    targetPercentage: input.targetPercentage,
+    sortOrder: input.sortOrder,
+  };
+}
+
+export function buildManagementLevelGroupUpdateData(
+  input: UpdateManagementLevelGroupInput,
+): Prisma.ManagementLevelGroupUncheckedUpdateInput {
+  return {
+    ...(input.name !== undefined ? { name: input.name } : {}),
+    ...(input.targetPercentage !== undefined ? { targetPercentage: input.targetPercentage } : {}),
+    ...(input.sortOrder !== undefined ? { sortOrder: input.sortOrder } : {}),
+  };
+}
+
+export function buildManagementLevelCreateData(
+  input: CreateManagementLevelInput,
+): Prisma.ManagementLevelUncheckedCreateInput {
+  return {
+    name: input.name,
+    groupId: input.groupId,
+  };
+}
+
+export function buildManagementLevelUpdateData(
+  input: UpdateManagementLevelInput,
+): Prisma.ManagementLevelUncheckedUpdateInput {
+  return {
+    ...(input.name !== undefined ? { name: input.name } : {}),
+    ...(input.groupId !== undefined ? { groupId: input.groupId } : {}),
+  };
+}
+
+export function assertManagementLevelDeletable(
+  level: ManagementLevelDeleteRecord,
+): void {
+  if (level._count.resources > 0) {
+    throw new TRPCError({
+      code: "PRECONDITION_FAILED",
+      message: `Cannot delete level assigned to ${level._count.resources} resource(s)`,
+    });
+  }
+}
@@ -4,11 +4,19 @@ import {
  UpdateManagementLevelGroupSchema,
  UpdateManagementLevelSchema,
 } from "@capakraken/shared";
-import { TRPCError } from "@trpc/server";
 import { z } from "zod";
 import { findUniqueOrThrow } from "../db/helpers.js";
 import { createAuditEntry } from "../lib/audit.js";
 import { adminProcedure, createTRPCRouter, planningReadProcedure } from "../trpc.js";
+import {
+  assertManagementLevelDeletable,
+  assertManagementLevelGroupNameAvailable,
+  assertManagementLevelNameAvailable,
+  buildManagementLevelCreateData,
+  buildManagementLevelGroupCreateData,
+  buildManagementLevelGroupUpdateData,
+  buildManagementLevelUpdateData,
+} from "./management-level-support.js";

 export const managementLevelRouter = createTRPCRouter({
  // ─── Groups ─────────────────────────────────────────────
@@ -39,16 +47,9 @@ export const managementLevelRouter = createTRPCRouter({
  createGroup: adminProcedure
    .input(CreateManagementLevelGroupSchema)
    .mutation(async ({ ctx, input }) => {
-      const existing = await ctx.db.managementLevelGroup.findUnique({ where: { name: input.name } });
-      if (existing) {
-        throw new TRPCError({ code: "CONFLICT", message: `Group "${input.name}" already exists` });
-      }
+      await assertManagementLevelGroupNameAvailable(ctx.db, input.name);
      const created = await ctx.db.managementLevelGroup.create({
-        data: {
-          name: input.name,
-          targetPercentage: input.targetPercentage,
-          sortOrder: input.sortOrder,
-        },
+        data: buildManagementLevelGroupCreateData(input),
        include: { levels: true },
      });

@@ -75,21 +76,14 @@ export const managementLevelRouter = createTRPCRouter({
      );

      if (input.data.name && input.data.name !== existing.name) {
-        const conflict = await ctx.db.managementLevelGroup.findUnique({ where: { name: input.data.name } });
-        if (conflict) {
-          throw new TRPCError({ code: "CONFLICT", message: `Group "${input.data.name}" already exists` });
-        }
+        await assertManagementLevelGroupNameAvailable(ctx.db, input.data.name, existing.id);
      }

      const before = existing as unknown as Record<string, unknown>;

      const updated = await ctx.db.managementLevelGroup.update({
        where: { id: input.id },
-        data: {
-          ...(input.data.name !== undefined ? { name: input.data.name } : {}),
-          ...(input.data.targetPercentage !== undefined ? { targetPercentage: input.data.targetPercentage } : {}),
-          ...(input.data.sortOrder !== undefined ? { sortOrder: input.data.sortOrder } : {}),
-        },
+        data: buildManagementLevelGroupUpdateData(input.data),
        include: { levels: true },
      });

@@ -118,13 +112,10 @@ export const managementLevelRouter = createTRPCRouter({
        "Group",
      );

-      const existing = await ctx.db.managementLevel.findUnique({ where: { name: input.name } });
-      if (existing) {
-        throw new TRPCError({ code: "CONFLICT", message: `Level "${input.name}" already exists` });
-      }
+      await assertManagementLevelNameAvailable(ctx.db, input.name);

      const created = await ctx.db.managementLevel.create({
-        data: { name: input.name, groupId: input.groupId },
+        data: buildManagementLevelCreateData(input),
      });

      void createAuditEntry({
@@ -150,20 +141,14 @@ export const managementLevelRouter = createTRPCRouter({
      );

      if (input.data.name && input.data.name !== existing.name) {
-        const conflict = await ctx.db.managementLevel.findUnique({ where: { name: input.data.name } });
-        if (conflict) {
-          throw new TRPCError({ code: "CONFLICT", message: `Level "${input.data.name}" already exists` });
-        }
+        await assertManagementLevelNameAvailable(ctx.db, input.data.name, existing.id);
      }

      const before = existing as unknown as Record<string, unknown>;

      const updated = await ctx.db.managementLevel.update({
        where: { id: input.id },
-        data: {
-          ...(input.data.name !== undefined ? { name: input.data.name } : {}),
-          ...(input.data.groupId !== undefined ? { groupId: input.data.groupId } : {}),
-        },
+        data: buildManagementLevelUpdateData(input.data),
      });

      void createAuditEntry({
@@ -191,12 +176,7 @@ export const managementLevelRouter = createTRPCRouter({
        }),
        "Level",
      );
-      if (level._count.resources > 0) {
-        throw new TRPCError({
-          code: "PRECONDITION_FAILED",
-          message: `Cannot delete level assigned to ${level._count.resources} resource(s)`,
-        });
-      }
+      assertManagementLevelDeletable(level);
      await ctx.db.managementLevel.delete({ where: { id: input.id } });

      void createAuditEntry({