Add circuit group reordering

src/db/repositories/circuit-group-structure-project-command.repository.ts

@@ -2,13 +2,17 @@ import { and, eq } from "drizzle-orm";
 import {
   assertCircuitGroupDeleteProjectCommand,
   assertCircuitGroupInsertProjectCommand,
+  assertCircuitGroupReorderProjectCommand,
   assertCircuitGroupUpdateProjectCommand,
   circuitGroupDeleteCommandType,
   circuitGroupInsertCommandType,
+  circuitGroupReorderCommandType,
   circuitGroupUpdateCommandType,
   createCircuitGroupDeleteProjectCommand,
   createCircuitGroupInsertProjectCommand,
+  createCircuitGroupReorderProjectCommand,
   createCircuitGroupUpdateProjectCommand,
+  type CircuitGroupReorderAssignment,
   type CircuitGroupSnapshot,
   type CircuitGroupStructureProjectCommand,
 } from "../../domain/models/circuit-group-structure-project-command.model.js";
@@ -68,6 +72,19 @@ export class CircuitGroupStructureProjectCommandRepository
         command.payload.expected
       );
     }
+    if (command.type === circuitGroupReorderCommandType) {
+      assertCircuitGroupReorderProjectCommand(command);
+      const inverseAssignments = this.reorder(
+        database,
+        projectId,
+        command.payload.circuitListId,
+        command.payload.assignments
+      );
+      return createCircuitGroupReorderProjectCommand(
+        command.payload.circuitListId,
+        inverseAssignments
+      );
+    }
     throw new Error("Unsupported circuit-group structure command.");
   }
 
@@ -168,6 +185,61 @@ export class CircuitGroupStructureProjectCommandRepository
     }
   }
 
+  private reorder(
+    database: AppDatabase,
+    projectId: string,
+    circuitListId: string,
+    assignments: CircuitGroupReorderAssignment[]
+  ) {
+    this.assertListOwnership(database, projectId, circuitListId);
+    const persisted = database
+      .select({
+        id: circuitSections.id,
+        sortOrder: circuitSections.sortOrder,
+      })
+      .from(circuitSections)
+      .where(eq(circuitSections.circuitListId, circuitListId))
+      .all();
+    const persistedById = new Map(
+      persisted.map((group) => [group.id, group])
+    );
+    if (
+      persisted.length !== assignments.length ||
+      assignments.some((assignment) => {
+        const group = persistedById.get(assignment.groupId);
+        return !group || group.sortOrder !== assignment.expectedSortOrder;
+      })
+    ) {
+      throw new Error(
+        "Circuit-group reorder must include every unchanged group in the list."
+      );
+    }
+    for (const assignment of assignments) {
+      if (assignment.expectedSortOrder === assignment.targetSortOrder) {
+        continue;
+      }
+      const updated = database
+        .update(circuitSections)
+        .set({ sortOrder: assignment.targetSortOrder })
+        .where(
+          and(
+            eq(circuitSections.id, assignment.groupId),
+            eq(circuitSections.circuitListId, circuitListId),
+            eq(circuitSections.sortOrder, assignment.expectedSortOrder)
+          )
+        )
+        .run();
+      if (updated.changes !== 1) {
+        throw new Error("Circuit group changed during reorder.");
+      }
+    }
+    return assignments.map((assignment) => ({
+      groupId: assignment.groupId,
+      expectedSortOrder: assignment.targetSortOrder,
+      targetSortOrder: assignment.expectedSortOrder,
+    }));
+  }
+
   private getCurrent(database: AppDatabase, id: string) {
     return database
       .select()