refactor(api): extract timeline allocation router support

packages/api/src/router/timeline-allocation-mutations.ts

@@ -1,26 +1,25 @@
 import type { PrismaClient } from "@capakraken/db";
 import { PermissionKey } from "@capakraken/shared";
-import { emitAllocationUpdated } from "../sse/event-bus.js";
 import { managerProcedure, requirePermission } from "../trpc.js";
-import {
-  createTimelineBatchQuickAssignments,
-  createTimelineQuickAssignment,
-} from "./timeline-allocation-assignment-procedure-support.js";
-import { shiftTimelineAllocations } from "./timeline-allocation-procedure-support.js";
 import {
   UpdateAllocationHoursSchema,
   timelineBatchQuickAssignInputSchema,
   timelineBatchShiftAllocationsInputSchema,
   timelineQuickAssignInputSchema,
 } from "./timeline-allocation-mutation-schema-support.js";
-import { applyTimelineInlineAllocationUpdate } from "./timeline-allocation-inline-support.js";
+import {
+  applyTimelineAllocationBatchShiftMutation,
+  createTimelineBatchQuickAssignMutation,
+  createTimelineQuickAssignMutation,
+  updateTimelineAllocationInlineMutation,
+} from "./timeline-allocation-router-support.js";
 
 export const timelineAllocationMutationProcedures = {
   updateAllocationInline: managerProcedure
     .input(UpdateAllocationHoursSchema)
     .mutation(async ({ ctx, input }) => {
       requirePermission(ctx, PermissionKey.MANAGE_ALLOCATIONS);
-      const updated = await applyTimelineInlineAllocationUpdate({
+      return updateTimelineAllocationInlineMutation({
         db: ctx.db as PrismaClient,
         allocationId: input.allocationId,
         hoursPerDay: input.hoursPerDay,
@@ -29,46 +28,26 @@ export const timelineAllocationMutationProcedures = {
         includeSaturday: input.includeSaturday,
         role: input.role,
       });
-
-      emitAllocationUpdated({
-        id: updated.id,
-        projectId: updated.projectId,
-        resourceId: updated.resourceId,
-      });
-
-      return updated;
     }),
 
   quickAssign: managerProcedure
     .input(timelineQuickAssignInputSchema)
     .mutation(async ({ ctx, input }) => {
       requirePermission(ctx, PermissionKey.MANAGE_ALLOCATIONS);
-      return createTimelineQuickAssignment(ctx.db as PrismaClient, {
-        ...input,
-        source: "quickAssign",
-      });
+      return createTimelineQuickAssignMutation(ctx.db as PrismaClient, input);
     }),
 
   batchQuickAssign: managerProcedure
     .input(timelineBatchQuickAssignInputSchema)
     .mutation(async ({ ctx, input }) => {
       requirePermission(ctx, PermissionKey.MANAGE_ALLOCATIONS);
-      return createTimelineBatchQuickAssignments(ctx.db as PrismaClient, {
-        assignments: input.assignments.map((assignment) => ({
-          ...assignment,
-          source: "batchQuickAssign" as const,
-        })),
-      });
+      return createTimelineBatchQuickAssignMutation(ctx.db as PrismaClient, input);
     }),
 
   batchShiftAllocations: managerProcedure
     .input(timelineBatchShiftAllocationsInputSchema)
     .mutation(async ({ ctx, input }) => {
       requirePermission(ctx, PermissionKey.MANAGE_ALLOCATIONS);
-      return shiftTimelineAllocations(ctx.db as PrismaClient, {
-        allocationIds: input.allocationIds,
-        daysDelta: input.daysDelta,
-        mode: input.mode,
-      });
+      return applyTimelineAllocationBatchShiftMutation(ctx.db as PrismaClient, input);
     }),
 };

packages/api/src/router/timeline-allocation-router-support.ts

@@ -0,0 +1,69 @@
+import type { PrismaClient } from "@capakraken/db";
+import { emitAllocationUpdated } from "../sse/event-bus.js";
+import {
+  createTimelineBatchQuickAssignments,
+  createTimelineQuickAssignment,
+} from "./timeline-allocation-assignment-procedure-support.js";
+import { applyTimelineInlineAllocationUpdate } from "./timeline-allocation-inline-support.js";
+import { shiftTimelineAllocations } from "./timeline-allocation-procedure-support.js";
+
+export async function updateTimelineAllocationInlineMutation(input: {
+  db: PrismaClient;
+  allocationId: string;
+  hoursPerDay?: number | undefined;
+  startDate?: Date | null | undefined;
+  endDate?: Date | null | undefined;
+  includeSaturday?: boolean | undefined;
+  role?: string | null | undefined;
+}) {
+  const updated = await applyTimelineInlineAllocationUpdate({
+    db: input.db,
+    allocationId: input.allocationId,
+    hoursPerDay: input.hoursPerDay,
+    startDate: input.startDate ?? undefined,
+    endDate: input.endDate ?? undefined,
+    includeSaturday: input.includeSaturday,
+    role: input.role ?? undefined,
+  });
+
+  emitAllocationUpdated({
+    id: updated.id,
+    projectId: updated.projectId,
+    resourceId: updated.resourceId,
+  });
+
+  return updated;
+}
+
+export async function createTimelineQuickAssignMutation(
+  db: PrismaClient,
+  input: Omit<Parameters<typeof createTimelineQuickAssignment>[1], "source">,
+) {
+  return createTimelineQuickAssignment(db, {
+    ...input,
+    source: "quickAssign",
+  });
+}
+
+export async function createTimelineBatchQuickAssignMutation(
+  db: PrismaClient,
+  input: {
+    assignments: Array<
+      Omit<Parameters<typeof createTimelineBatchQuickAssignments>[1]["assignments"][number], "source">
+    >;
+  },
+) {
+  return createTimelineBatchQuickAssignments(db, {
+    assignments: input.assignments.map((assignment) => ({
+      ...assignment,
+      source: "batchQuickAssign" as const,
+    })),
+  });
+}
+
+export async function applyTimelineAllocationBatchShiftMutation(
+  db: PrismaClient,
+  input: Parameters<typeof shiftTimelineAllocations>[1],
+) {
+  return shiftTimelineAllocations(db, input);
+}