Make circuit reordering atomic

src/db/repositories/circuit.repository.ts

@@ -137,6 +137,46 @@ export class CircuitRepository {
       .orderBy(asc(circuits.sortOrder), asc(circuits.equipmentIdentifier));
   }
 
+  updateSortOrdersSafely(sectionId: string, orderedCircuitIds: string[]) {
+    if (orderedCircuitIds.length === 0) {
+      return;
+    }
+    if (new Set(orderedCircuitIds).size !== orderedCircuitIds.length) {
+      throw new Error("Stromkreise dürfen in der Reihenfolge nicht mehrfach vorkommen.");
+    }
+
+    db.transaction((tx) => {
+      const sectionCircuits = tx
+        .select({ id: circuits.id })
+        .from(circuits)
+        .where(eq(circuits.sectionId, sectionId))
+        .all();
+      const sectionCircuitIds = new Set(sectionCircuits.map((circuit) => circuit.id));
+      if (
+        sectionCircuits.length !== orderedCircuitIds.length ||
+        orderedCircuitIds.some((circuitId) => !sectionCircuitIds.has(circuitId))
+      ) {
+        throw new Error("Die Reihenfolge muss alle Stromkreise des Bereichs enthalten.");
+      }
+
+      for (let index = 0; index < orderedCircuitIds.length; index += 1) {
+        const result = tx
+          .update(circuits)
+          .set({ sortOrder: (index + 1) * 10 })
+          .where(
+            and(
+              eq(circuits.sectionId, sectionId),
+              eq(circuits.id, orderedCircuitIds[index])
+            )
+          )
+          .run();
+        if (result.changes !== 1) {
+          throw new Error("Ein Stromkreis wurde vor Abschluss der Sortierung verändert.");
+        }
+      }
+    });
+  }
+
   async updateEquipmentIdentifiersSafely(
     circuitListId: string,
     updates: Array<{ id: string; equipmentIdentifier: string }>,

src/domain/services/circuit-write.service.ts

@@ -476,32 +476,7 @@ export class CircuitWriteService {
       }
     }
 
-    for (let index = 0; index < input.orderedCircuitIds.length; index += 1) {
-      const circuitId = input.orderedCircuitIds[index];
-      const circuit = sectionCircuits.find((entry) => entry.id === circuitId);
-      if (!circuit) {
-        throw new Error("Invalid circuit id.");
-      }
-      await this.circuitRepository.update(circuit.id, {
-        sectionId: circuit.sectionId,
-        equipmentIdentifier: circuit.equipmentIdentifier,
-        displayName: circuit.displayName ?? undefined,
-        sortOrder: (index + 1) * 10,
-        protectionType: circuit.protectionType ?? undefined,
-        protectionRatedCurrent: circuit.protectionRatedCurrent ?? undefined,
-        protectionCharacteristic: circuit.protectionCharacteristic ?? undefined,
-        cableType: circuit.cableType ?? undefined,
-        cableCrossSection: circuit.cableCrossSection ?? undefined,
-        cableLength: circuit.cableLength ?? undefined,
-        rcdAssignment: circuit.rcdAssignment ?? undefined,
-        terminalDesignation: circuit.terminalDesignation ?? undefined,
-        voltage: circuit.voltage ?? undefined,
-        controlRequirement: circuit.controlRequirement ?? undefined,
-        status: circuit.status ?? undefined,
-        isReserve: Boolean(circuit.isReserve),
-        remark: circuit.remark ?? undefined,
-      });
-    }
+    this.circuitRepository.updateSortOrdersSafely(sectionId, input.orderedCircuitIds);
     return this.circuitRepository.listBySection(sectionId);
   }
 }