refactor(api): reorganise allocation router into allocation/ subdirectory

Moves read, assignment-procedures, assignment-mutations, and demand procedures into allocation/ so the domain boundary is discoverable without grep. Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
2026-04-09 14:44:17 +02:00
parent d3bfa8ca98
commit b2c8d98b25
14 changed files with 46 additions and 46 deletions
@@ -0,0 +1,229 @@
+import {
+  createAssignment,
+  updateAssignment,
+} from "@capakraken/application";
+import {
+  AllocationStatus,
+  CreateAllocationSchema,
+  CreateAssignmentSchema,
+  PermissionKey,
+  UpdateAllocationSchema,
+  UpdateAssignmentSchema,
+} from "@capakraken/shared";
+import { z } from "zod";
+import { findUniqueOrThrow } from "../../db/helpers.js";
+import {
+  publishAllocationCreated,
+  publishAllocationDeleted,
+  publishAllocationUpdated,
+  publishBatchAllocationDeletes,
+  publishBatchAllocationStatusUpdates,
+} from "./assignment-effects.js";
+import {
+  batchDeleteAllocationsWithAudit,
+  batchUpdateAllocationStatusWithAudit,
+  createAllocationReadModelEntry,
+  deleteAllocationWithAudit,
+  deleteAssignmentWithAudit,
+  ensureAssignmentRecord,
+  updateAllocationWithAudit,
+} from "./assignment-mutations.js";
+import {
+  managerProcedure,
+  requirePermission,
+} from "../../trpc.js";
+
+export const allocationAssignmentProcedures = {
+  create: managerProcedure
+    .input(CreateAllocationSchema)
+    .mutation(async ({ ctx, input }) => {
+      requirePermission(ctx, PermissionKey.MANAGE_ALLOCATIONS);
+      const allocation = await ctx.db.$transaction(async (tx) =>
+        createAllocationReadModelEntry(
+          tx as Parameters<typeof createAssignment>[0],
+          input,
+        ));
+
+      publishAllocationCreated(ctx.db, {
+        id: allocation.id,
+        projectId: allocation.projectId,
+        resourceId: allocation.resourceId,
+      }, { dispatchWebhook: true });
+      return allocation;
+    }),
+
+  createAssignment: managerProcedure
+    .input(CreateAssignmentSchema)
+    .mutation(async ({ ctx, input }) => {
+      requirePermission(ctx, PermissionKey.MANAGE_ALLOCATIONS);
+
+      const assignment = await ctx.db.$transaction(async (tx) => {
+        return createAssignment(
+          tx as unknown as Parameters<typeof createAssignment>[0],
+          input,
+        );
+      });
+
+      publishAllocationCreated(ctx.db, {
+        id: assignment.id,
+        projectId: assignment.projectId,
+        resourceId: assignment.resourceId,
+      });
+
+      return assignment;
+    }),
+
+  ensureAssignment: managerProcedure
+    .input(z.object({
+      resourceId: z.string(),
+      projectId: z.string(),
+      startDate: z.coerce.date(),
+      endDate: z.coerce.date(),
+      hoursPerDay: z.number().min(0.5).max(24),
+      role: z.string().optional(),
+    }))
+    .mutation(async ({ ctx, input }) => {
+      requirePermission(ctx, PermissionKey.MANAGE_ALLOCATIONS);
+      const result = await ensureAssignmentRecord(ctx.db, {
+        resourceId: input.resourceId,
+        projectId: input.projectId,
+        startDate: input.startDate,
+        endDate: input.endDate,
+        hoursPerDay: input.hoursPerDay,
+        ...(input.role !== undefined ? { role: input.role } : {}),
+      });
+
+      if (result.action === "reactivated") {
+        publishAllocationUpdated(ctx.db, {
+          id: result.assignment.id,
+          projectId: result.assignment.projectId,
+          resourceId: result.assignment.resourceId,
+        }, { dispatchWebhook: true });
+
+        return result;
+      }
+
+      publishAllocationCreated(ctx.db, {
+        id: result.assignment.id,
+        projectId: result.assignment.projectId,
+        resourceId: result.assignment.resourceId,
+      });
+
+      return result;
+    }),
+
+  updateAssignment: managerProcedure
+    .input(z.object({ id: z.string(), data: UpdateAssignmentSchema }))
+    .mutation(async ({ ctx, input }) => {
+      requirePermission(ctx, PermissionKey.MANAGE_ALLOCATIONS);
+      const existing = await findUniqueOrThrow(
+        ctx.db.assignment.findUnique({
+          where: { id: input.id },
+          select: { resourceId: true },
+        }),
+        "Assignment",
+      );
+
+      const updated = await ctx.db.$transaction(async (tx) => {
+        return updateAssignment(
+          tx as unknown as Parameters<typeof updateAssignment>[0],
+          input.id,
+          input.data,
+        );
+      });
+
+      publishAllocationUpdated(ctx.db, {
+        id: updated.id,
+        projectId: updated.projectId,
+        resourceId: updated.resourceId,
+        resourceIds: [existing.resourceId, updated.resourceId],
+      }, { dispatchWebhook: true });
+
+      return updated;
+    }),
+
+  update: managerProcedure
+    .input(z.object({ id: z.string(), data: UpdateAllocationSchema }))
+    .mutation(async ({ ctx, input }) => {
+      requirePermission(ctx, PermissionKey.MANAGE_ALLOCATIONS);
+      const { existing, updated } = await updateAllocationWithAudit(ctx.db, input.id, input.data);
+
+      const affectedResourceIds = [existing.entry.resourceId, updated.resourceId].filter(
+        (resourceId): resourceId is string => Boolean(resourceId),
+      );
+
+      publishAllocationUpdated(ctx.db, {
+        id: updated.id,
+        projectId: updated.projectId,
+        resourceId: updated.resourceId,
+        resourceIds: affectedResourceIds,
+      });
+
+      return updated;
+    }),
+
+  deleteAssignment: managerProcedure
+    .input(z.object({ id: z.string() }))
+    .mutation(async ({ ctx, input }) => {
+      requirePermission(ctx, PermissionKey.MANAGE_ALLOCATIONS);
+      const existing = await deleteAssignmentWithAudit(ctx.db, input.id);
+
+      publishAllocationDeleted(ctx.db, {
+        id: existing.id,
+        projectId: existing.projectId,
+        resourceId: existing.resourceId,
+      });
+
+      return { success: true };
+    }),
+
+  delete: managerProcedure
+    .input(z.object({ id: z.string() }))
+    .mutation(async ({ ctx, input }) => {
+      requirePermission(ctx, PermissionKey.MANAGE_ALLOCATIONS);
+      const existing = await deleteAllocationWithAudit(ctx.db, input.id);
+
+      publishAllocationDeleted(ctx.db, {
+        id: existing.entry.id,
+        projectId: existing.projectId,
+        resourceId: existing.entry.resourceId,
+      });
+
+      return { success: true };
+    }),
+
+  batchDelete: managerProcedure
+    .input(z.object({ ids: z.array(z.string()).min(1).max(100) }))
+    .mutation(async ({ ctx, input }) => {
+      requirePermission(ctx, PermissionKey.MANAGE_ALLOCATIONS);
+      const existing = await batchDeleteAllocationsWithAudit(ctx.db, input.ids);
+
+      publishBatchAllocationDeletes(ctx.db, existing.map((allocation) => ({
+        id: allocation.entry.id,
+        projectId: allocation.projectId,
+        resourceId: allocation.entry.resourceId,
+      })));
+
+      return { count: existing.length };
+    }),
+
+  batchUpdateStatus: managerProcedure
+    .input(
+      z.object({
+        ids: z.array(z.string()).min(1).max(100),
+        status: z.nativeEnum(AllocationStatus),
+      }),
+    )
+    .mutation(async ({ ctx, input }) => {
+      requirePermission(ctx, PermissionKey.MANAGE_ALLOCATIONS);
+      const updated = await batchUpdateAllocationStatusWithAudit(ctx.db, input);
+
+      publishBatchAllocationStatusUpdates(ctx.db, updated.map((allocation) => ({
+        id: allocation.id,
+        projectId: allocation.projectId,
+        resourceId: allocation.resourceId,
+      })));
+
+      return { count: updated.length };
+    }),
+};