Centralize device row update transactions

2026-07-26 11:28:06 +02:00
parent e4d22caf09
commit 214ad728cd
5 changed files with 142 additions and 104 deletions
@@ -21,8 +21,7 @@ import {
  toCircuitDeviceRowPatchValues,
  type CircuitDeviceRowPatchInput,
 } from "./circuit-device-row.persistence.js";
-import { applyProjectHistoryTransition } from "./project-history.persistence.js";
-import { appendProjectRevision } from "./project-revision.persistence.js";
+import { executeProjectCommandTransactionWithAppliedForward } from "./project-command-transaction.persistence.js";

 type CircuitDeviceRow = typeof circuitDeviceRows.$inferSelect;

@@ -34,99 +33,95 @@ export class CircuitDeviceRowProjectCommandRepository
  executeUpdate(input: ExecuteCircuitDeviceRowUpdateCommandInput) {
    assertCircuitDeviceRowUpdateProjectCommand(input.command);

-    return this.database.transaction((tx) => {
-      const current = tx
-        .select()
-        .from(circuitDeviceRows)
-        .where(eq(circuitDeviceRows.id, input.command.payload.rowId))
-        .get();
-      if (!current) {
-        throw new Error("Invalid device row id.");
-      }
+    return executeProjectCommandTransactionWithAppliedForward(
+      this.database,
+      input,
+      (tx) => this.applyCommand(tx, input)
+    );
+  }

-      const circuit = tx
-        .select({ circuitListId: circuits.circuitListId })
-        .from(circuits)
-        .where(eq(circuits.id, current.circuitId))
-        .get();
-      const owningList = circuit
-        ? tx
-            .select({ id: circuitLists.id })
-            .from(circuitLists)
-            .where(
-              and(
-                eq(circuitLists.id, circuit.circuitListId),
-                eq(circuitLists.projectId, input.projectId)
-              )
+  private applyCommand(
+    tx: AppDatabase,
+    input: ExecuteCircuitDeviceRowUpdateCommandInput
+  ) {
+    const current = tx
+      .select()
+      .from(circuitDeviceRows)
+      .where(eq(circuitDeviceRows.id, input.command.payload.rowId))
+      .get();
+    if (!current) {
+      throw new Error("Invalid device row id.");
+    }
+
+    const circuit = tx
+      .select({ circuitListId: circuits.circuitListId })
+      .from(circuits)
+      .where(eq(circuits.id, current.circuitId))
+      .get();
+    const owningList = circuit
+      ? tx
+          .select({ id: circuitLists.id })
+          .from(circuitLists)
+          .where(
+            and(
+              eq(circuitLists.id, circuit.circuitListId),
+              eq(circuitLists.projectId, input.projectId)
            )
-            .get()
-        : null;
-      if (!owningList) {
-        throw new Error("Circuit device row does not belong to project.");
-      }
+          )
+          .get()
+      : null;
+    if (!owningList) {
+      throw new Error("Circuit device row does not belong to project.");
+    }

-      const patch = Object.fromEntries(
-        input.command.payload.changes.map((change) => [
-          change.field,
-          change.value,
-        ])
-      ) as CircuitDeviceRowPatchInput;
-      this.assertLinkedProjectDevice(tx, input.projectId, patch);
-      this.assertRoom(tx, input.projectId, patch);
+    const patch = Object.fromEntries(
+      input.command.payload.changes.map((change) => [
+        change.field,
+        change.value,
+      ])
+    ) as CircuitDeviceRowPatchInput;
+    this.assertLinkedProjectDevice(tx, input.projectId, patch);
+    this.assertRoom(tx, input.projectId, patch);

-      const overriddenFields = deriveOverriddenFieldsForLocalEdit(
-        current,
-        patch
-      );
-      if (
-        overriddenFields !== undefined &&
-        patch.overriddenFields === undefined
-      ) {
-        patch.overriddenFields = overriddenFields;
-      }
+    const overriddenFields = deriveOverriddenFieldsForLocalEdit(
+      current,
+      patch
+    );
+    if (
+      overriddenFields !== undefined &&
+      patch.overriddenFields === undefined
+    ) {
+      patch.overriddenFields = overriddenFields;
+    }

-      const appliedForward = createCircuitDeviceRowUpdateProjectCommand(
-        current.id,
-        patch as CircuitDeviceRowUpdatePatch
-      );
-      const inversePatch = Object.fromEntries(
-        appliedForward.payload.changes.map((change) => [
-          change.field,
-          getCircuitDeviceRowFieldValue(current, change.field),
-        ])
-      ) as CircuitDeviceRowUpdatePatch;
-      const inverse = createCircuitDeviceRowUpdateProjectCommand(
-        current.id,
-        inversePatch
-      );
+    const appliedForward = createCircuitDeviceRowUpdateProjectCommand(
+      current.id,
+      patch as CircuitDeviceRowUpdatePatch
+    );
+    const inversePatch = Object.fromEntries(
+      appliedForward.payload.changes.map((change) => [
+        change.field,
+        getCircuitDeviceRowFieldValue(current, change.field),
+      ])
+    ) as CircuitDeviceRowUpdatePatch;
+    const inverse = createCircuitDeviceRowUpdateProjectCommand(
+      current.id,
+      inversePatch
+    );

-      const update = tx
-        .update(circuitDeviceRows)
-        .set(toCircuitDeviceRowPatchValues(patch))
-        .where(eq(circuitDeviceRows.id, current.id))
-        .run();
-      if (update.changes !== 1) {
-        throw new Error("Circuit device row changed before command execution.");
-      }
+    const update = tx
+      .update(circuitDeviceRows)
+      .set(toCircuitDeviceRowPatchValues(patch))
+      .where(eq(circuitDeviceRows.id, current.id))
+      .run();
+    if (update.changes !== 1) {
+      throw new Error("Circuit device row changed before command execution.");
+    }

-      const revision = appendProjectRevision(tx, {
-        projectId: input.projectId,
-        expectedRevision: input.expectedRevision,
-        source: input.source,
-        description: input.description,
-        actorId: input.actorId,
-        forward: appliedForward,
-        inverse,
-      });
-      applyProjectHistoryTransition(tx, {
-        projectId: input.projectId,
-        source: input.source,
-        recordedChangeSetId: revision.changeSetId,
-        targetChangeSetId: input.historyTargetChangeSetId,
-      });
-
-      return { revision, inverse };
-    });
+    return {
+      forward: appliedForward,
+      inverse,
+    };
  }

  private assertLinkedProjectDevice(
@@ -19,6 +19,14 @@ export interface ProjectCommandTransactionInput<
  command: Command;
 }

+export interface AppliedProjectCommand<
+  Forward extends SerializedProjectCommand<unknown>,
+  Inverse extends SerializedProjectCommand<unknown>,
+> {
+  forward: Forward;
+  inverse: Inverse;
+}
+
 export function executeProjectCommandTransaction<
  Command extends SerializedProjectCommand<unknown>,
  Inverse extends SerializedProjectCommand<unknown>,
@@ -26,16 +34,55 @@ export function executeProjectCommandTransaction<
  database: AppDatabase,
  input: ProjectCommandTransactionInput<Command>,
  applyCommand: (transaction: AppDatabase) => Inverse
+): { revision: AppendedProjectRevision; inverse: Inverse } {
+  return executeAppliedProjectCommandTransaction(
+    database,
+    input,
+    (transaction) => ({
+      forward: input.command,
+      inverse: applyCommand(transaction),
+    })
+  );
+}
+
+export function executeProjectCommandTransactionWithAppliedForward<
+  Command extends SerializedProjectCommand<unknown>,
+  Forward extends SerializedProjectCommand<unknown>,
+  Inverse extends SerializedProjectCommand<unknown>,
+>(
+  database: AppDatabase,
+  input: ProjectCommandTransactionInput<Command>,
+  applyCommand: (
+    transaction: AppDatabase
+  ) => AppliedProjectCommand<Forward, Inverse>
+): { revision: AppendedProjectRevision; inverse: Inverse } {
+  return executeAppliedProjectCommandTransaction(
+    database,
+    input,
+    applyCommand
+  );
+}
+
+function executeAppliedProjectCommandTransaction<
+  Command extends SerializedProjectCommand<unknown>,
+  Forward extends SerializedProjectCommand<unknown>,
+  Inverse extends SerializedProjectCommand<unknown>,
+>(
+  database: AppDatabase,
+  input: ProjectCommandTransactionInput<Command>,
+  applyCommand: (
+    transaction: AppDatabase
+  ) => AppliedProjectCommand<Forward, Inverse>
 ): { revision: AppendedProjectRevision; inverse: Inverse } {
  return database.transaction((tx) => {
-    const inverse = applyCommand(tx);
+    const { forward, inverse } = applyCommand(tx);
    const revision = appendProjectRevision(tx, {
      projectId: input.projectId,
      expectedRevision: input.expectedRevision,
      source: input.source,
      description: input.description,
      actorId: input.actorId,
-      forward: input.command,
+      forward,
      inverse,
    });
    applyProjectHistoryTransition(tx, {