Isolate circuit section transactions

src/db/repositories/circuit.repository.ts

@@ -1,5 +1,5 @@
 import crypto from "node:crypto";
-import { and, asc, eq, inArray, ne } from "drizzle-orm";
+import { and, asc, eq, ne } from "drizzle-orm";
 import { db } from "../client.js";
 import { circuits } from "../schema/circuits.js";
 import {
@@ -169,89 +169,4 @@ 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 }>,
-    tempNamespace: string
-  ) {
-    if (updates.length === 0) {
-      return;
-    }
-    // better-sqlite3 transactions are synchronous callbacks. Do not make this callback
-    // async or return a Promise, otherwise statements may run outside the transaction scope.
-    db.transaction((tx) => {
-      const ids = updates.map((entry) => entry.id);
-      const existing = tx
-        .select({ id: circuits.id })
-        .from(circuits)
-        .where(and(eq(circuits.circuitListId, circuitListId), inArray(circuits.id, ids)))
-        .all();
-      if (existing.length !== ids.length) {
-        throw new Error("One or more circuit ids are invalid for circuit list.");
-      }
-
-      // Direct identifier swaps can violate UNIQUE(circuit_list_id, equipment_identifier)
-      // mid-update (for example A->B while B->A). Two-phase strategy prevents that:
-      // 1) assign unique temporary identifiers for all affected circuits
-      // 2) assign final user-visible identifiers
-      const stamp = Date.now();
-      for (let index = 0; index < updates.length; index += 1) {
-        const entry = updates[index];
-        const tempIdentifier = `__tmp_renumber_${tempNamespace}_${stamp}_${index}`;
-        tx
-          .update(circuits)
-          .set({ equipmentIdentifier: tempIdentifier })
-          .where(and(eq(circuits.circuitListId, circuitListId), eq(circuits.id, entry.id)))
-          .run();
-      }
-
-      for (const entry of updates) {
-        tx
-          .update(circuits)
-          .set({ equipmentIdentifier: entry.equipmentIdentifier })
-          .where(and(eq(circuits.circuitListId, circuitListId), eq(circuits.id, entry.id)))
-          .run();
-      }
-    });
-  }
 }