Add device row move history

2026-07-23 22:29:44 +02:00
parent ca13efbfcb
commit 0a51703315
14 changed files with 940 additions and 13 deletions
@@ -0,0 +1,181 @@
+import { and, eq, inArray } from "drizzle-orm";
+import {
+  assertCircuitDeviceRowMoveProjectCommand,
+  createCircuitDeviceRowMoveProjectCommand,
+} from "../../domain/models/circuit-device-row-move-project-command.model.js";
+import type {
+  CircuitDeviceRowMoveProjectCommandStore,
+  ExecuteCircuitDeviceRowMoveCommandInput,
+} from "../../domain/ports/circuit-device-row-move-project-command.store.js";
+import type { AppDatabase } from "../database-context.js";
+import { circuitDeviceRows } from "../schema/circuit-device-rows.js";
+import { circuitLists } from "../schema/circuit-lists.js";
+import { circuits } from "../schema/circuits.js";
+import { applyProjectHistoryTransition } from "./project-history.persistence.js";
+import { appendProjectRevision } from "./project-revision.persistence.js";
+
+export class CircuitDeviceRowMoveProjectCommandRepository
+  implements CircuitDeviceRowMoveProjectCommandStore
+{
+  constructor(private readonly database: AppDatabase) {}
+
+  execute(input: ExecuteCircuitDeviceRowMoveCommandInput) {
+    assertCircuitDeviceRowMoveProjectCommand(input.command);
+
+    return this.database.transaction((tx) => {
+      const rowIds = input.command.payload.moves.map(
+        (move) => move.rowId
+      );
+      const persistedRows = tx
+        .select({
+          id: circuitDeviceRows.id,
+          circuitId: circuitDeviceRows.circuitId,
+          sortOrder: circuitDeviceRows.sortOrder,
+        })
+        .from(circuitDeviceRows)
+        .where(inArray(circuitDeviceRows.id, rowIds))
+        .all();
+      if (persistedRows.length !== rowIds.length) {
+        throw new Error(
+          "One or more circuit device rows do not exist."
+        );
+      }
+      const rowsById = new Map(
+        persistedRows.map((row) => [row.id, row])
+      );
+      for (const move of input.command.payload.moves) {
+        const row = rowsById.get(move.rowId);
+        if (
+          !row ||
+          row.circuitId !== move.expectedCircuitId ||
+          row.sortOrder !== move.expectedSortOrder
+        ) {
+          throw new Error(
+            "Circuit device row changed before move execution."
+          );
+        }
+      }
+
+      const circuitIds = [
+        ...new Set(
+          input.command.payload.moves.flatMap((move) => [
+            move.expectedCircuitId,
+            move.targetCircuitId,
+          ])
+        ),
+      ];
+      const participatingCircuits = tx
+        .select({
+          id: circuits.id,
+          circuitListId: circuits.circuitListId,
+          projectId: circuitLists.projectId,
+        })
+        .from(circuits)
+        .innerJoin(
+          circuitLists,
+          eq(circuitLists.id, circuits.circuitListId)
+        )
+        .where(inArray(circuits.id, circuitIds))
+        .all();
+      if (participatingCircuits.length !== circuitIds.length) {
+        throw new Error(
+          "One or more move circuits do not exist."
+        );
+      }
+      if (
+        participatingCircuits.some(
+          (circuit) => circuit.projectId !== input.projectId
+        )
+      ) {
+        throw new Error("Move circuit does not belong to project.");
+      }
+      const circuitListIds = new Set(
+        participatingCircuits.map(
+          (circuit) => circuit.circuitListId
+        )
+      );
+      if (circuitListIds.size !== 1) {
+        throw new Error(
+          "All moved rows and targets must belong to one circuit list."
+        );
+      }
+
+      const inverse = createCircuitDeviceRowMoveProjectCommand(
+        input.command.payload.moves.map((move) => {
+          const current = rowsById.get(move.rowId)!;
+          return {
+            rowId: move.rowId,
+            expectedCircuitId: move.targetCircuitId,
+            expectedSortOrder: move.targetSortOrder,
+            targetCircuitId: current.circuitId,
+            targetSortOrder: current.sortOrder,
+          };
+        })
+      );
+
+      for (const move of input.command.payload.moves) {
+        const result = tx
+          .update(circuitDeviceRows)
+          .set({
+            circuitId: move.targetCircuitId,
+            sortOrder: move.targetSortOrder,
+          })
+          .where(
+            and(
+              eq(circuitDeviceRows.id, move.rowId),
+              eq(
+                circuitDeviceRows.circuitId,
+                move.expectedCircuitId
+              ),
+              eq(
+                circuitDeviceRows.sortOrder,
+                move.expectedSortOrder
+              )
+            )
+          )
+          .run();
+        if (result.changes !== 1) {
+          throw new Error(
+            "Circuit device row changed during move execution."
+          );
+        }
+      }
+
+      for (const circuitId of circuitIds) {
+        const remainingRow = tx
+          .select({ id: circuitDeviceRows.id })
+          .from(circuitDeviceRows)
+          .where(eq(circuitDeviceRows.circuitId, circuitId))
+          .limit(1)
+          .get();
+        const updated = tx
+          .update(circuits)
+          .set({ isReserve: remainingRow ? 0 : 1 })
+          .where(eq(circuits.id, circuitId))
+          .run();
+        if (updated.changes !== 1) {
+          throw new Error(
+            "Circuit changed during device-row move execution."
+          );
+        }
+      }
+
+      const revision = appendProjectRevision(tx, {
+        projectId: input.projectId,
+        expectedRevision: input.expectedRevision,
+        source: input.source,
+        description: input.description,
+        actorId: input.actorId,
+        forward: input.command,
+        inverse,
+      });
+      applyProjectHistoryTransition(tx, {
+        projectId: input.projectId,
+        source: input.source,
+        recordedChangeSetId: revision.changeSetId,
+        targetChangeSetId: input.historyTargetChangeSetId,
+      });
+      return { revision, inverse };
+    });
+  }
+}