refactor(api): extract utilization category procedures

2026-03-31 21:09:13 +02:00
parent e08a992a65
commit b17398e00b
3 changed files with 318 additions and 94 deletions
@@ -0,0 +1,122 @@
+import {
+  CreateUtilizationCategorySchema,
+  UpdateUtilizationCategorySchema,
+} from "@capakraken/shared";
+import { z } from "zod";
+import { findUniqueOrThrow } from "../db/helpers.js";
+import { createAuditEntry } from "../lib/audit.js";
+import type { TRPCContext } from "../trpc.js";
+import {
+  assertUtilizationCategoryCodeAvailable,
+  buildUtilizationCategoryCreateData,
+  buildUtilizationCategoryListWhere,
+  buildUtilizationCategoryUpdateData,
+  unsetDefaultUtilizationCategory,
+} from "./utilization-category-support.js";
+
+export const UtilizationCategoryListInputSchema = z.object({
+  isActive: z.boolean().optional(),
+}).optional();
+
+export const UtilizationCategoryByIdInputSchema = z.object({
+  id: z.string(),
+});
+
+export const CreateUtilizationCategoryInputSchema = CreateUtilizationCategorySchema;
+
+export const UpdateUtilizationCategoryInputSchema = z.object({
+  id: z.string(),
+  data: UpdateUtilizationCategorySchema,
+});
+
+type UtilizationCategoryContext = Pick<TRPCContext, "db" | "dbUser">;
+
+export async function listUtilizationCategories(
+  ctx: Pick<TRPCContext, "db">,
+  input: z.infer<typeof UtilizationCategoryListInputSchema>,
+) {
+  return ctx.db.utilizationCategory.findMany({
+    where: buildUtilizationCategoryListWhere(input ?? {}),
+    orderBy: { sortOrder: "asc" },
+  });
+}
+
+export async function getUtilizationCategoryById(
+  ctx: Pick<TRPCContext, "db">,
+  input: z.infer<typeof UtilizationCategoryByIdInputSchema>,
+) {
+  return findUniqueOrThrow(
+    ctx.db.utilizationCategory.findUnique({
+      where: { id: input.id },
+      include: { _count: { select: { projects: true } } },
+    }),
+    "Utilization category",
+  );
+}
+
+export async function createUtilizationCategory(
+  ctx: UtilizationCategoryContext,
+  input: z.infer<typeof CreateUtilizationCategoryInputSchema>,
+) {
+  await assertUtilizationCategoryCodeAvailable(ctx.db, input.code);
+
+  if (input.isDefault) {
+    await unsetDefaultUtilizationCategory(ctx.db);
+  }
+
+  const created = await ctx.db.utilizationCategory.create({
+    data: buildUtilizationCategoryCreateData(input),
+  });
+
+  void createAuditEntry({
+    db: ctx.db,
+    entityType: "UtilizationCategory",
+    entityId: created.id,
+    entityName: created.name,
+    action: "CREATE",
+    userId: ctx.dbUser?.id,
+    after: created as unknown as Record<string, unknown>,
+    source: "ui",
+  });
+
+  return created;
+}
+
+export async function updateUtilizationCategory(
+  ctx: UtilizationCategoryContext,
+  input: z.infer<typeof UpdateUtilizationCategoryInputSchema>,
+) {
+  const existing = await findUniqueOrThrow(
+    ctx.db.utilizationCategory.findUnique({ where: { id: input.id } }),
+    "Utilization category",
+  );
+
+  if (input.data.code && input.data.code !== existing.code) {
+    await assertUtilizationCategoryCodeAvailable(ctx.db, input.data.code, existing.id);
+  }
+
+  if (input.data.isDefault) {
+    await unsetDefaultUtilizationCategory(ctx.db, input.id);
+  }
+
+  const before = existing as unknown as Record<string, unknown>;
+
+  const updated = await ctx.db.utilizationCategory.update({
+    where: { id: input.id },
+    data: buildUtilizationCategoryUpdateData(input.data),
+  });
+
+  void createAuditEntry({
+    db: ctx.db,
+    entityType: "UtilizationCategory",
+    entityId: updated.id,
+    entityName: updated.name,
+    action: "UPDATE",
+    userId: ctx.dbUser?.id,
+    before,
+    after: updated as unknown as Record<string, unknown>,
+    source: "ui",
+  });
+
+  return updated;
+}
@@ -1,106 +1,29 @@
-import {
-  CreateUtilizationCategorySchema,
-  UpdateUtilizationCategorySchema,
-} from "@capakraken/shared";
-import { z } from "zod";
-import { findUniqueOrThrow } from "../db/helpers.js";
-import { createAuditEntry } from "../lib/audit.js";
 import { adminProcedure, createTRPCRouter, planningReadProcedure } from "../trpc.js";
 import {
-  assertUtilizationCategoryCodeAvailable,
-  buildUtilizationCategoryCreateData,
-  buildUtilizationCategoryListWhere,
-  buildUtilizationCategoryUpdateData,
-  unsetDefaultUtilizationCategory,
-} from "./utilization-category-support.js";
+  CreateUtilizationCategoryInputSchema,
+  UpdateUtilizationCategoryInputSchema,
+  UtilizationCategoryByIdInputSchema,
+  UtilizationCategoryListInputSchema,
+  createUtilizationCategory,
+  getUtilizationCategoryById,
+  listUtilizationCategories,
+  updateUtilizationCategory,
+} from "./utilization-category-procedure-support.js";

 export const utilizationCategoryRouter = createTRPCRouter({
  list: planningReadProcedure
-    .input(z.object({ isActive: z.boolean().optional() }).optional())
-    .query(async ({ ctx, input }) => {
-      return ctx.db.utilizationCategory.findMany({
-        where: buildUtilizationCategoryListWhere(input ?? {}),
-        orderBy: { sortOrder: "asc" },
-      });
-    }),
+    .input(UtilizationCategoryListInputSchema)
+    .query(({ ctx, input }) => listUtilizationCategories(ctx, input)),

  getById: planningReadProcedure
-    .input(z.object({ id: z.string() }))
-    .query(async ({ ctx, input }) => {
-      const cat = await findUniqueOrThrow(
-        ctx.db.utilizationCategory.findUnique({
-          where: { id: input.id },
-          include: { _count: { select: { projects: true } } },
-        }),
-        "Utilization category",
-      );
-      return cat;
-    }),
+    .input(UtilizationCategoryByIdInputSchema)
+    .query(({ ctx, input }) => getUtilizationCategoryById(ctx, input)),

  create: adminProcedure
-    .input(CreateUtilizationCategorySchema)
-    .mutation(async ({ ctx, input }) => {
-      await assertUtilizationCategoryCodeAvailable(ctx.db, input.code);
-
-      // If setting as default, unset the current default first
-      if (input.isDefault) {
-        await unsetDefaultUtilizationCategory(ctx.db);
-      }
-
-      const created = await ctx.db.utilizationCategory.create({
-        data: buildUtilizationCategoryCreateData(input),
-      });
-
-      void createAuditEntry({
-        db: ctx.db,
-        entityType: "UtilizationCategory",
-        entityId: created.id,
-        entityName: created.name,
-        action: "CREATE",
-        userId: ctx.dbUser?.id,
-        after: created as unknown as Record<string, unknown>,
-        source: "ui",
-      });
-
-      return created;
-    }),
+    .input(CreateUtilizationCategoryInputSchema)
+    .mutation(({ ctx, input }) => createUtilizationCategory(ctx, input)),

  update: adminProcedure
-    .input(z.object({ id: z.string(), data: UpdateUtilizationCategorySchema }))
-    .mutation(async ({ ctx, input }) => {
-      const existing = await findUniqueOrThrow(
-        ctx.db.utilizationCategory.findUnique({ where: { id: input.id } }),
-        "Utilization category",
-      );
-
-      if (input.data.code && input.data.code !== existing.code) {
-        await assertUtilizationCategoryCodeAvailable(ctx.db, input.data.code, existing.id);
-      }
-
-      // If setting as default, unset others
-      if (input.data.isDefault) {
-        await unsetDefaultUtilizationCategory(ctx.db, input.id);
-      }
-
-      const before = existing as unknown as Record<string, unknown>;
-
-      const updated = await ctx.db.utilizationCategory.update({
-        where: { id: input.id },
-        data: buildUtilizationCategoryUpdateData(input.data),
-      });
-
-      void createAuditEntry({
-        db: ctx.db,
-        entityType: "UtilizationCategory",
-        entityId: updated.id,
-        entityName: updated.name,
-        action: "UPDATE",
-        userId: ctx.dbUser?.id,
-        before,
-        after: updated as unknown as Record<string, unknown>,
-        source: "ui",
-      });
-
-      return updated;
-    }),
+    .input(UpdateUtilizationCategoryInputSchema)
+    .mutation(({ ctx, input }) => updateUtilizationCategory(ctx, input)),
 });