Add circuit history commands

2026-07-23 22:18:36 +02:00
parent bd5f4f925f
commit ca13efbfcb
16 changed files with 1402 additions and 85 deletions
@@ -17,8 +17,10 @@ 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 { projectDevices } from "../schema/project-devices.js";
-import { rooms } from "../schema/rooms.js";
+import {
+  assertCircuitDeviceRowReferencesInProject,
+  toCircuitDeviceRowSnapshot,
+} from "./circuit-device-row-structure.persistence.js";
 import { applyProjectHistoryTransition } from "./project-history.persistence.js";
 import { appendProjectRevision } from "./project-revision.persistence.js";

@@ -93,7 +95,7 @@ export class CircuitDeviceRowStructureProjectCommandRepository
      );
    }
    this.assertCircuitInProject(database, projectId, row.circuitId);
-    this.assertReferencesInProject(database, projectId, row);
+    assertCircuitDeviceRowReferencesInProject(database, projectId, row);

    const existing = database
      .select({ id: circuitDeviceRows.id })
@@ -194,69 +196,4 @@ export class CircuitDeviceRowStructureProjectCommandRepository
      throw new Error("Circuit does not belong to project.");
    }
  }
-
-  private assertReferencesInProject(
-    database: AppDatabase,
-    projectId: string,
-    row: CircuitDeviceRowSnapshot
-  ) {
-    if (row.linkedProjectDeviceId !== null) {
-      const device = database
-        .select({ id: projectDevices.id })
-        .from(projectDevices)
-        .where(
-          and(
-            eq(projectDevices.id, row.linkedProjectDeviceId),
-            eq(projectDevices.projectId, projectId)
-          )
-        )
-        .get();
-      if (!device) {
-        throw new Error("Invalid linked project device id.");
-      }
-    }
-    if (row.roomId !== null) {
-      const room = database
-        .select({ id: rooms.id })
-        .from(rooms)
-        .where(
-          and(
-            eq(rooms.id, row.roomId),
-            eq(rooms.projectId, projectId)
-          )
-        )
-        .get();
-      if (!room) {
-        throw new Error("Invalid room id.");
-      }
-    }
-  }
-}
-
-function toCircuitDeviceRowSnapshot(
-  row: typeof circuitDeviceRows.$inferSelect
-): CircuitDeviceRowSnapshot {
-  return {
-    id: row.id,
-    circuitId: row.circuitId,
-    linkedProjectDeviceId: row.linkedProjectDeviceId,
-    legacyConsumerId: row.legacyConsumerId,
-    sortOrder: row.sortOrder,
-    name: row.name,
-    displayName: row.displayName,
-    phaseType: row.phaseType,
-    connectionKind: row.connectionKind,
-    costGroup: row.costGroup,
-    category: row.category,
-    level: row.level,
-    roomId: row.roomId,
-    roomNumberSnapshot: row.roomNumberSnapshot,
-    roomNameSnapshot: row.roomNameSnapshot,
-    quantity: row.quantity,
-    powerPerUnit: row.powerPerUnit,
-    simultaneityFactor: row.simultaneityFactor,
-    cosPhi: row.cosPhi,
-    remark: row.remark,
-    overriddenFields: row.overriddenFields,
-  };
 }
@@ -0,0 +1,71 @@
+import { and, eq } from "drizzle-orm";
+import type { CircuitDeviceRowSnapshot } from "../../domain/models/circuit-device-row-structure-project-command.model.js";
+import type { AppDatabase } from "../database-context.js";
+import { circuitDeviceRows } from "../schema/circuit-device-rows.js";
+import { projectDevices } from "../schema/project-devices.js";
+import { rooms } from "../schema/rooms.js";
+
+export function assertCircuitDeviceRowReferencesInProject(
+  database: AppDatabase,
+  projectId: string,
+  row: CircuitDeviceRowSnapshot
+) {
+  if (row.linkedProjectDeviceId !== null) {
+    const device = database
+      .select({ id: projectDevices.id })
+      .from(projectDevices)
+      .where(
+        and(
+          eq(projectDevices.id, row.linkedProjectDeviceId),
+          eq(projectDevices.projectId, projectId)
+        )
+      )
+      .get();
+    if (!device) {
+      throw new Error("Invalid linked project device id.");
+    }
+  }
+  if (row.roomId !== null) {
+    const room = database
+      .select({ id: rooms.id })
+      .from(rooms)
+      .where(
+        and(
+          eq(rooms.id, row.roomId),
+          eq(rooms.projectId, projectId)
+        )
+      )
+      .get();
+    if (!room) {
+      throw new Error("Invalid room id.");
+    }
+  }
+}
+
+export function toCircuitDeviceRowSnapshot(
+  row: typeof circuitDeviceRows.$inferSelect
+): CircuitDeviceRowSnapshot {
+  return {
+    id: row.id,
+    circuitId: row.circuitId,
+    linkedProjectDeviceId: row.linkedProjectDeviceId,
+    legacyConsumerId: row.legacyConsumerId,
+    sortOrder: row.sortOrder,
+    name: row.name,
+    displayName: row.displayName,
+    phaseType: row.phaseType,
+    connectionKind: row.connectionKind,
+    costGroup: row.costGroup,
+    category: row.category,
+    level: row.level,
+    roomId: row.roomId,
+    roomNumberSnapshot: row.roomNumberSnapshot,
+    roomNameSnapshot: row.roomNameSnapshot,
+    quantity: row.quantity,
+    powerPerUnit: row.powerPerUnit,
+    simultaneityFactor: row.simultaneityFactor,
+    cosPhi: row.cosPhi,
+    remark: row.remark,
+    overriddenFields: row.overriddenFields,
+  };
+}
@@ -0,0 +1,291 @@
+import { and, asc, eq, inArray } from "drizzle-orm";
+import {
+  assertCircuitDeleteProjectCommand,
+  assertCircuitInsertProjectCommand,
+  circuitDeleteCommandType,
+  circuitInsertCommandType,
+  createCircuitDeleteProjectCommand,
+  createCircuitInsertProjectCommand,
+  type CircuitSnapshot,
+  type CircuitStructureProjectCommand,
+} from "../../domain/models/circuit-structure-project-command.model.js";
+import type {
+  CircuitStructureProjectCommandStore,
+  ExecuteCircuitStructureCommandInput,
+} from "../../domain/ports/circuit-structure-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 { circuitSections } from "../schema/circuit-sections.js";
+import { circuits } from "../schema/circuits.js";
+import {
+  assertCircuitDeviceRowReferencesInProject,
+  toCircuitDeviceRowSnapshot,
+} from "./circuit-device-row-structure.persistence.js";
+import { applyProjectHistoryTransition } from "./project-history.persistence.js";
+import { appendProjectRevision } from "./project-revision.persistence.js";
+
+export class CircuitStructureProjectCommandRepository
+  implements CircuitStructureProjectCommandStore
+{
+  constructor(private readonly database: AppDatabase) {}
+
+  execute(input: ExecuteCircuitStructureCommandInput) {
+    return this.database.transaction((tx) => {
+      const inverse = this.applyCommand(
+        tx,
+        input.projectId,
+        input.source,
+        input.command
+      );
+      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 };
+    });
+  }
+
+  private applyCommand(
+    database: AppDatabase,
+    projectId: string,
+    source: ExecuteCircuitStructureCommandInput["source"],
+    command: CircuitStructureProjectCommand
+  ): CircuitStructureProjectCommand {
+    if (command.type === circuitInsertCommandType) {
+      assertCircuitInsertProjectCommand(command);
+      return this.insert(
+        database,
+        projectId,
+        source,
+        command.payload.circuit
+      );
+    }
+    if (command.type === circuitDeleteCommandType) {
+      assertCircuitDeleteProjectCommand(command);
+      return this.delete(
+        database,
+        projectId,
+        command.payload.circuitId,
+        command.payload.expectedCircuitListId
+      );
+    }
+    throw new Error("Unsupported circuit structure command.");
+  }
+
+  private insert(
+    database: AppDatabase,
+    projectId: string,
+    source: ExecuteCircuitStructureCommandInput["source"],
+    snapshot: CircuitSnapshot
+  ) {
+    this.assertCircuitLocation(database, projectId, snapshot);
+
+    const existingCircuit = database
+      .select({ id: circuits.id })
+      .from(circuits)
+      .where(eq(circuits.id, snapshot.id))
+      .get();
+    if (existingCircuit) {
+      throw new Error("Circuit id already exists.");
+    }
+    const duplicateIdentifier = database
+      .select({ id: circuits.id })
+      .from(circuits)
+      .where(
+        and(
+          eq(circuits.circuitListId, snapshot.circuitListId),
+          eq(
+            circuits.equipmentIdentifier,
+            snapshot.equipmentIdentifier
+          )
+        )
+      )
+      .get();
+    if (duplicateIdentifier) {
+      throw new Error(
+        "Duplicate equipmentIdentifier in circuit list."
+      );
+    }
+
+    if (snapshot.deviceRows.length > 0) {
+      const rowIds = snapshot.deviceRows.map((row) => row.id);
+      const existingRow = database
+        .select({ id: circuitDeviceRows.id })
+        .from(circuitDeviceRows)
+        .where(inArray(circuitDeviceRows.id, rowIds))
+        .limit(1)
+        .get();
+      if (existingRow) {
+        throw new Error("Circuit device-row id already exists.");
+      }
+      for (const row of snapshot.deviceRows) {
+        if (source === "user" && row.legacyConsumerId !== null) {
+          throw new Error(
+            "User commands cannot assign legacy consumer ids."
+          );
+        }
+        assertCircuitDeviceRowReferencesInProject(
+          database,
+          projectId,
+          row
+        );
+      }
+    }
+
+    database
+      .insert(circuits)
+      .values({
+        id: snapshot.id,
+        circuitListId: snapshot.circuitListId,
+        sectionId: snapshot.sectionId,
+        equipmentIdentifier: snapshot.equipmentIdentifier,
+        displayName: snapshot.displayName,
+        sortOrder: snapshot.sortOrder,
+        protectionType: snapshot.protectionType,
+        protectionRatedCurrent: snapshot.protectionRatedCurrent,
+        protectionCharacteristic: snapshot.protectionCharacteristic,
+        cableType: snapshot.cableType,
+        cableCrossSection: snapshot.cableCrossSection,
+        cableLength: snapshot.cableLength,
+        rcdAssignment: snapshot.rcdAssignment,
+        terminalDesignation: snapshot.terminalDesignation,
+        voltage: snapshot.voltage,
+        controlRequirement: snapshot.controlRequirement,
+        status: snapshot.status,
+        isReserve: snapshot.isReserve ? 1 : 0,
+        remark: snapshot.remark,
+      })
+      .run();
+    if (snapshot.deviceRows.length > 0) {
+      database.insert(circuitDeviceRows).values(snapshot.deviceRows).run();
+    }
+
+    return createCircuitDeleteProjectCommand(
+      snapshot.id,
+      snapshot.circuitListId
+    );
+  }
+
+  private delete(
+    database: AppDatabase,
+    projectId: string,
+    circuitId: string,
+    expectedCircuitListId: string
+  ) {
+    const circuit = database
+      .select()
+      .from(circuits)
+      .where(eq(circuits.id, circuitId))
+      .get();
+    if (!circuit || circuit.circuitListId !== expectedCircuitListId) {
+      throw new Error("Circuit changed before command execution.");
+    }
+    const owningList = database
+      .select({ id: circuitLists.id })
+      .from(circuitLists)
+      .where(
+        and(
+          eq(circuitLists.id, circuit.circuitListId),
+          eq(circuitLists.projectId, projectId)
+        )
+      )
+      .get();
+    if (!owningList) {
+      throw new Error("Circuit does not belong to project.");
+    }
+
+    const rows = database
+      .select()
+      .from(circuitDeviceRows)
+      .where(eq(circuitDeviceRows.circuitId, circuit.id))
+      .orderBy(
+        asc(circuitDeviceRows.sortOrder),
+        asc(circuitDeviceRows.id)
+      )
+      .all();
+    const inverse = createCircuitInsertProjectCommand({
+      id: circuit.id,
+      circuitListId: circuit.circuitListId,
+      sectionId: circuit.sectionId,
+      equipmentIdentifier: circuit.equipmentIdentifier,
+      displayName: circuit.displayName,
+      sortOrder: circuit.sortOrder,
+      protectionType: circuit.protectionType,
+      protectionRatedCurrent: circuit.protectionRatedCurrent,
+      protectionCharacteristic: circuit.protectionCharacteristic,
+      cableType: circuit.cableType,
+      cableCrossSection: circuit.cableCrossSection,
+      cableLength: circuit.cableLength,
+      rcdAssignment: circuit.rcdAssignment,
+      terminalDesignation: circuit.terminalDesignation,
+      voltage: circuit.voltage,
+      controlRequirement: circuit.controlRequirement,
+      status: circuit.status,
+      isReserve: Boolean(circuit.isReserve),
+      remark: circuit.remark,
+      deviceRows: rows.map(toCircuitDeviceRowSnapshot),
+    });
+
+    const result = database
+      .delete(circuits)
+      .where(
+        and(
+          eq(circuits.id, circuitId),
+          eq(circuits.circuitListId, expectedCircuitListId)
+        )
+      )
+      .run();
+    if (result.changes !== 1) {
+      throw new Error("Circuit could not be deleted.");
+    }
+    return inverse;
+  }
+
+  private assertCircuitLocation(
+    database: AppDatabase,
+    projectId: string,
+    snapshot: CircuitSnapshot
+  ) {
+    const list = database
+      .select({ id: circuitLists.id })
+      .from(circuitLists)
+      .where(
+        and(
+          eq(circuitLists.id, snapshot.circuitListId),
+          eq(circuitLists.projectId, projectId)
+        )
+      )
+      .get();
+    if (!list) {
+      throw new Error("Circuit list does not belong to project.");
+    }
+    const section = database
+      .select({ id: circuitSections.id })
+      .from(circuitSections)
+      .where(
+        and(
+          eq(circuitSections.id, snapshot.sectionId),
+          eq(
+            circuitSections.circuitListId,
+            snapshot.circuitListId
+          )
+        )
+      )
+      .get();
+    if (!section) {
+      throw new Error("Section does not belong to circuit list.");
+    }
+  }
+}