Add external object new row command

src/db/repositories/external-object-new-row-project-command.repository.ts

@@ -0,0 +1,266 @@
+import { and, eq, inArray, isNull } from "drizzle-orm";
+import { assertCircuitDeviceRowQuantity } from "../../domain/calculations/circuit-device-row-quantity.js";
+import {
+  assertExternalObjectNewRowProjectCommand,
+  externalObjectAssignToNewRowCommandType,
+  externalObjectDeleteCreatedRowCommandType,
+  invertExternalObjectNewRowProjectCommand,
+  type ExternalObjectNewRowProjectCommand,
+} from "../../domain/models/external-object-new-row-project-command.model.js";
+import type { CircuitDeviceRowSnapshot } from "../../domain/models/circuit-device-row-structure-project-command.model.js";
+import type { ExternalObjectNewRowProjectCommandStore } from "../../domain/ports/external-object-new-row-project-command.store.js";
+import { isElectricalPhaseType } from "../../domain/services/project-voltage.service.js";
+import type { ExternalModelObjectSnapshot } from "../../external-model/domain/external-model-contracts.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 { externalModelObjects } from "../schema/external-model-objects.js";
+import { externalRoomMappings } from "../schema/external-room-mappings.js";
+import {
+  assertCircuitDeviceRowReferencesInProject,
+  toCircuitDeviceRowInsertValues,
+  toCircuitDeviceRowSnapshot,
+} from "./circuit-device-row-structure.persistence.js";
+import { executeProjectCommandTransaction } from "./project-command-transaction.persistence.js";
+import { updateDerivedCircuitVoltage } from "./project-voltage.persistence.js";
+
+export class ExternalObjectNewRowProjectCommandRepository
+  implements ExternalObjectNewRowProjectCommandStore
+{
+  constructor(private readonly database: AppDatabase) {}
+
+  execute(input: Parameters<ExternalObjectNewRowProjectCommandStore["execute"]>[0]) {
+    assertExternalObjectNewRowProjectCommand(input.command);
+    if (
+      input.source === "user" &&
+      input.command.type === externalObjectDeleteCreatedRowCommandType
+    ) {
+      throw new Error("Created external rows may only be removed through project history.");
+    }
+    return executeProjectCommandTransaction(this.database, input, (tx) => {
+      if (input.command.type === externalObjectAssignToNewRowCommandType) {
+        this.insert(tx, input.projectId, input.command);
+      } else {
+        this.remove(tx, input.projectId, input.command);
+      }
+      return invertExternalObjectNewRowProjectCommand(input.command);
+    });
+  }
+
+  private insert(
+    database: AppDatabase,
+    projectId: string,
+    command: ExternalObjectNewRowProjectCommand
+  ) {
+    const row = command.payload.row;
+    const context = this.loadCircuitContext(database, projectId, row.circuitId);
+    if (!isElectricalPhaseType(row.phaseType)) {
+      throw new Error("External device-row phase type is invalid.");
+    }
+    if (row.category !== context.category) {
+      throw new Error("External device-row category does not match target circuit group.");
+    }
+    assertCircuitDeviceRowReferencesInProject(database, projectId, row);
+    if (database.select({ id: circuitDeviceRows.id }).from(circuitDeviceRows)
+      .where(eq(circuitDeviceRows.id, row.id)).get()) {
+      throw new Error("External device-row id already exists.");
+    }
+    const objects = this.loadExpectedObjects(database, projectId, command);
+    this.assertTargetCompatibility(
+      database,
+      row,
+      context.distributionBoardId,
+      context.category,
+      objects.map((object) => object.target),
+      new Set(command.payload.confirmedConflictObjectIds)
+    );
+    assertCircuitDeviceRowQuantity({
+      quantity: row.quantity,
+      manualQuantity: 0,
+      externalObjects: objects.map(({ target }) => ({
+        effectiveQuantity: target.planningValues.effectiveQuantity,
+      })),
+    });
+
+    database.insert(circuitDeviceRows).values(toCircuitDeviceRowInsertValues(row)).run();
+    this.updateCircuitState(database, projectId, row.circuitId);
+    this.applyObjectLinks(database, objects);
+  }
+
+  private remove(
+    database: AppDatabase,
+    projectId: string,
+    command: ExternalObjectNewRowProjectCommand
+  ) {
+    const expectedRow = command.payload.row;
+    this.loadCircuitContext(database, projectId, expectedRow.circuitId);
+    const currentRow = database.select().from(circuitDeviceRows)
+      .where(eq(circuitDeviceRows.id, expectedRow.id)).get();
+    if (!currentRow || !same(toCircuitDeviceRowSnapshot(currentRow), expectedRow)) {
+      throw new Error("Created external device row changed before history removal.");
+    }
+    const objects = this.loadExpectedObjects(database, projectId, command);
+    const linkedObjects = database.select({ id: externalModelObjects.id })
+      .from(externalModelObjects)
+      .where(eq(externalModelObjects.circuitDeviceRowId, expectedRow.id)).all();
+    if (
+      linkedObjects.length !== objects.length ||
+      linkedObjects.some(({ id }) => !objects.some((object) => object.expected.id === id))
+    ) {
+      throw new Error("Created external device row has different object links.");
+    }
+    this.applyObjectLinks(database, objects);
+    const deleted = database.delete(circuitDeviceRows)
+      .where(eq(circuitDeviceRows.id, expectedRow.id)).run();
+    if (deleted.changes !== 1) {
+      throw new Error("Created external device row changed during history removal.");
+    }
+    this.updateCircuitState(database, projectId, expectedRow.circuitId);
+  }
+
+  private loadCircuitContext(database: AppDatabase, projectId: string, circuitId: string) {
+    const context = database.select({
+      projectId: circuitLists.projectId,
+      distributionBoardId: circuitLists.distributionBoardId,
+      category: circuitSections.category,
+    }).from(circuits)
+      .innerJoin(circuitLists, eq(circuitLists.id, circuits.circuitListId))
+      .innerJoin(circuitSections, eq(circuitSections.id, circuits.sectionId))
+      .where(eq(circuits.id, circuitId)).get();
+    if (!context || context.projectId !== projectId || context.category === null) {
+      throw new Error("Target circuit does not belong to the project.");
+    }
+    return {
+      projectId: context.projectId,
+      distributionBoardId: context.distributionBoardId,
+      category: context.category,
+    };
+  }
+
+  private loadExpectedObjects(
+    database: AppDatabase,
+    projectId: string,
+    command: ExternalObjectNewRowProjectCommand
+  ) {
+    const transitions = new Map(
+      command.payload.objects.map((transition) => [transition.expected.id, transition])
+    );
+    const current = database.select().from(externalModelObjects)
+      .where(inArray(externalModelObjects.id, [...transitions.keys()])).all();
+    if (current.length !== transitions.size) {
+      throw new Error("One or more external objects no longer exist.");
+    }
+    for (const object of current) {
+      const expected = transitions.get(object.id)!.expected;
+      if (object.projectId !== projectId || !same(toExternalObjectSnapshot(object), expected)) {
+        throw new Error("External object changed before new-row assignment.");
+      }
+    }
+    return command.payload.objects;
+  }
+
+  private assertTargetCompatibility(
+    database: AppDatabase,
+    row: CircuitDeviceRowSnapshot,
+    distributionBoardId: string,
+    category: string,
+    objects: ExternalModelObjectSnapshot[],
+    confirmedConflicts: Set<string>
+  ) {
+    const roomMappings = database.select().from(externalRoomMappings)
+      .where(eq(externalRoomMappings.projectId, objects[0]!.projectId)).all();
+    const roomIdByMappingId = new Map(roomMappings.map((mapping) => [mapping.id, mapping.roomId]));
+    const selectionMarkers = new Set(
+      objects.map((object) => object.acceptedSourceValues.selectionMarker.trim())
+    );
+    if (selectionMarkers.size > 1) {
+      throw new Error("External objects with different selection markers require separate rows.");
+    }
+    for (const object of objects) {
+      if (object.distributionBoardId !== distributionBoardId) {
+        throw new Error("External object distribution does not match target circuit.");
+      }
+      if (object.planningValues.category !== category) {
+        throw new Error("External object category does not match target circuit group.");
+      }
+      const objectRoomId = object.externalRoomMappingId === null
+        ? null
+        : roomIdByMappingId.get(object.externalRoomMappingId) ?? null;
+      if (objectRoomId !== row.roomId) {
+        throw new Error("External object room does not match the new device row.");
+      }
+      if (!matchesRowPlanningValues(row, object) && !confirmedConflicts.has(object.id)) {
+        throw new Error("External object planning values require explicit conflict confirmation.");
+      }
+    }
+  }
+
+  private applyObjectLinks(
+    database: AppDatabase,
+    objects: ExternalObjectNewRowProjectCommand["payload"]["objects"]
+  ) {
+    for (const { expected, target } of objects) {
+      const result = database.update(externalModelObjects)
+        .set({ circuitDeviceRowId: target.circuitDeviceRowId })
+        .where(and(
+          eq(externalModelObjects.id, expected.id),
+          expected.circuitDeviceRowId === null
+            ? isNull(externalModelObjects.circuitDeviceRowId)
+            : eq(externalModelObjects.circuitDeviceRowId, expected.circuitDeviceRowId)
+        )).run();
+      if (result.changes !== 1) {
+        throw new Error("External object changed during new-row assignment.");
+      }
+    }
+  }
+
+  private updateCircuitState(database: AppDatabase, projectId: string, circuitId: string) {
+    const remaining = database.select({ id: circuitDeviceRows.id }).from(circuitDeviceRows)
+      .where(eq(circuitDeviceRows.circuitId, circuitId)).limit(1).get();
+    const result = database.update(circuits).set({ isReserve: remaining ? 0 : 1 })
+      .where(eq(circuits.id, circuitId)).run();
+    if (result.changes !== 1) throw new Error("Target circuit changed during row assignment.");
+    updateDerivedCircuitVoltage(database, projectId, circuitId);
+  }
+}
+
+function matchesRowPlanningValues(
+  row: CircuitDeviceRowSnapshot,
+  object: ExternalModelObjectSnapshot
+) {
+  const planning = object.planningValues;
+  return (
+    row.displayName === (planning.displayName ?? row.displayName) &&
+    row.linkedProjectDeviceId === object.linkedProjectDeviceId &&
+    row.category === planning.category &&
+    row.connectionKind === planning.connectionKind &&
+    (planning.powerPerUnitW === null || row.powerPerUnit === planning.powerPerUnitW / 1000) &&
+    row.simultaneityFactor === planning.simultaneityFactor &&
+    row.cosPhi === planning.cosPhi &&
+    row.costGroup === planning.costGroup &&
+    row.remark === planning.remark
+  );
+}
+
+function toExternalObjectSnapshot(
+  object: typeof externalModelObjects.$inferSelect
+): ExternalModelObjectSnapshot {
+  return { ...object };
+}
+
+function same(left: unknown, right: unknown) {
+  return canonicalJson(left) === canonicalJson(right);
+}
+
+function canonicalJson(value: unknown): string {
+  if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
+  if (value !== null && typeof value === "object") {
+    const record = value as Record<string, unknown>;
+    return `{${Object.keys(record).sort().map((key) =>
+      `${JSON.stringify(key)}:${canonicalJson(record[key])}`
+    ).join(",")}}`;
+  }
+  return JSON.stringify(value);
+}

src/domain/models/external-object-new-row-project-command.model.ts

@@ -0,0 +1,163 @@
+import type { ExternalModelObjectSnapshot } from "../../external-model/domain/external-model-contracts.js";
+import {
+  assertCircuitDeviceRowInsertProjectCommand,
+  circuitDeviceRowInsertCommandType,
+  circuitDeviceRowStructureCommandSchemaVersion,
+  type CircuitDeviceRowSnapshot,
+} from "./circuit-device-row-structure-project-command.model.js";
+import type { SerializedProjectCommand } from "./project-command.model.js";
+import { parseExternalModelStateSnapshot } from "./project-state-snapshot.model.js";
+
+export const externalObjectAssignToNewRowCommandType =
+  "external-object.assign-to-new-row" as const;
+export const externalObjectDeleteCreatedRowCommandType =
+  "external-object.unassign-and-delete-created-row" as const;
+export const externalObjectNewRowCommandSchemaVersion = 1 as const;
+
+export interface ExternalObjectNewRowPayload {
+  row: CircuitDeviceRowSnapshot;
+  objects: Array<{
+    expected: ExternalModelObjectSnapshot;
+    target: ExternalModelObjectSnapshot;
+  }>;
+  confirmedConflictObjectIds: string[];
+}
+
+export interface ExternalObjectNewRowProjectCommand
+  extends SerializedProjectCommand<ExternalObjectNewRowPayload> {
+  schemaVersion: typeof externalObjectNewRowCommandSchemaVersion;
+  type:
+    | typeof externalObjectAssignToNewRowCommandType
+    | typeof externalObjectDeleteCreatedRowCommandType;
+}
+
+export function createExternalObjectNewRowProjectCommand(
+  type: ExternalObjectNewRowProjectCommand["type"],
+  payload: ExternalObjectNewRowPayload
+): ExternalObjectNewRowProjectCommand {
+  const command: ExternalObjectNewRowProjectCommand = {
+    schemaVersion: externalObjectNewRowCommandSchemaVersion,
+    type,
+    payload: {
+      row: {
+        ...payload.row,
+        manualQuantity: payload.row.manualQuantity ?? payload.row.quantity,
+      },
+      objects: payload.objects,
+      confirmedConflictObjectIds: [...payload.confirmedConflictObjectIds],
+    },
+  };
+  assertExternalObjectNewRowProjectCommand(command);
+  return command;
+}
+
+export function invertExternalObjectNewRowProjectCommand(
+  command: ExternalObjectNewRowProjectCommand
+) {
+  return createExternalObjectNewRowProjectCommand(
+    command.type === externalObjectAssignToNewRowCommandType
+      ? externalObjectDeleteCreatedRowCommandType
+      : externalObjectAssignToNewRowCommandType,
+    {
+      row: command.payload.row,
+      objects: command.payload.objects.map(({ expected, target }) => ({
+        expected: target,
+        target: expected,
+      })),
+      confirmedConflictObjectIds: command.payload.confirmedConflictObjectIds,
+    }
+  );
+}
+
+export function assertExternalObjectNewRowProjectCommand(
+  command: SerializedProjectCommand<unknown>
+): asserts command is ExternalObjectNewRowProjectCommand {
+  if (
+    command.schemaVersion !== externalObjectNewRowCommandSchemaVersion ||
+    (command.type !== externalObjectAssignToNewRowCommandType &&
+      command.type !== externalObjectDeleteCreatedRowCommandType) ||
+    !isRecord(command.payload) ||
+    !Array.isArray(command.payload.objects) ||
+    command.payload.objects.length === 0 ||
+    !Array.isArray(command.payload.confirmedConflictObjectIds)
+  ) {
+    throw new Error("Unsupported external object new-row command.");
+  }
+  const row = parseRow(command.payload.row);
+  if (row.manualQuantity !== 0) {
+    throw new Error("An external-only device row must start with zero manual quantity.");
+  }
+  const objectIds = new Set<string>();
+  for (const transition of command.payload.objects) {
+    if (!isRecord(transition)) throw new Error("Invalid external object transition.");
+    const expected = parseObject(transition.expected);
+    const target = parseObject(transition.target);
+    if (expected.id !== target.id || objectIds.has(expected.id)) {
+      throw new Error("New-row assignment contains mismatched or duplicate objects.");
+    }
+    objectIds.add(expected.id);
+    const assigning = command.type === externalObjectAssignToNewRowCommandType;
+    if (
+      (assigning && (expected.circuitDeviceRowId !== null || target.circuitDeviceRowId !== row.id)) ||
+      (!assigning && (expected.circuitDeviceRowId !== row.id || target.circuitDeviceRowId !== null))
+    ) {
+      throw new Error("External object links do not match the new-row action.");
+    }
+    assertOnlyAssignmentChanged(expected, target);
+  }
+  const confirmedIds = new Set<string>();
+  for (const objectId of command.payload.confirmedConflictObjectIds) {
+    if (typeof objectId !== "string" || !objectIds.has(objectId) || confirmedIds.has(objectId)) {
+      throw new Error("New-row assignment contains an invalid conflict confirmation.");
+    }
+    confirmedIds.add(objectId);
+  }
+}
+
+function parseRow(value: unknown): CircuitDeviceRowSnapshot {
+  const envelope = {
+    schemaVersion: circuitDeviceRowStructureCommandSchemaVersion,
+    type: circuitDeviceRowInsertCommandType,
+    payload: { row: value },
+  };
+  assertCircuitDeviceRowInsertProjectCommand(envelope);
+  const row = envelope.payload.row;
+  if (row.manualQuantity === undefined) {
+    throw new Error("External object new-row command requires manual quantity.");
+  }
+  return row;
+}
+
+function parseObject(value: unknown): ExternalModelObjectSnapshot {
+  return parseExternalModelStateSnapshot({
+    source: null,
+    importBatches: [],
+    roomMappings: [],
+    objects: [value],
+  }).objects[0]!;
+}
+
+function assertOnlyAssignmentChanged(
+  expected: ExternalModelObjectSnapshot,
+  target: ExternalModelObjectSnapshot
+) {
+  const expectedRest = { ...expected, circuitDeviceRowId: null };
+  const targetRest = { ...target, circuitDeviceRowId: null };
+  if (canonicalJson(expectedRest) !== canonicalJson(targetRest)) {
+    throw new Error("New-row assignment may only change the external object row link.");
+  }
+}
+
+function canonicalJson(value: unknown): string {
+  if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
+  if (isRecord(value)) {
+    return `{${Object.keys(value).sort().map((key) =>
+      `${JSON.stringify(key)}:${canonicalJson(value[key])}`
+    ).join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}

src/domain/ports/external-object-new-row-project-command.store.ts

@@ -0,0 +1,19 @@
+import type { ExternalObjectNewRowProjectCommand } from "../models/external-object-new-row-project-command.model.js";
+import type { AppendedProjectRevision, ProjectRevisionSource } from "./project-revision.store.js";
+
+export interface ExecuteExternalObjectNewRowCommandInput {
+  projectId: string;
+  expectedRevision: number;
+  source: ProjectRevisionSource;
+  description?: string;
+  actorId?: string;
+  historyTargetChangeSetId?: string;
+  command: ExternalObjectNewRowProjectCommand;
+}
+
+export interface ExternalObjectNewRowProjectCommandStore {
+  execute(input: ExecuteExternalObjectNewRowCommandInput): {
+    revision: AppendedProjectRevision;
+    inverse: ExternalObjectNewRowProjectCommand;
+  };
+}

src/domain/services/project-command.service.ts

@@ -176,6 +176,12 @@ import {
   externalObjectRowAssignmentCommandType,
 } from "../models/external-object-row-assignment-project-command.model.js";
 import type { ExternalObjectRowAssignmentProjectCommandStore } from "../ports/external-object-row-assignment-project-command.store.js";
+import {
+  assertExternalObjectNewRowProjectCommand,
+  externalObjectAssignToNewRowCommandType,
+  externalObjectDeleteCreatedRowCommandType,
+} from "../models/external-object-new-row-project-command.model.js";
+import type { ExternalObjectNewRowProjectCommandStore } from "../ports/external-object-new-row-project-command.store.js";
 
 interface DispatchProjectCommandInput {
   projectId: string;
@@ -213,7 +219,8 @@ export class ProjectCommandService implements ProjectCommandExecutor {
     private readonly historyStore: ProjectHistoryStore,
     private readonly externalCsvConfigurationStore?: ExternalCsvConfigurationProjectCommandStore,
     private readonly externalInitialImportStore?: ExternalInitialImportProjectCommandStore,
-    private readonly externalObjectRowAssignmentStore?: ExternalObjectRowAssignmentProjectCommandStore
+    private readonly externalObjectRowAssignmentStore?: ExternalObjectRowAssignmentProjectCommandStore,
+    private readonly externalObjectNewRowStore?: ExternalObjectNewRowProjectCommandStore
   ) {}
 
   executeUser(
@@ -600,6 +607,17 @@ export class ProjectCommandService implements ProjectCommandExecutor {
           command: input.command,
         }).revision;
       }
+      case externalObjectAssignToNewRowCommandType:
+      case externalObjectDeleteCreatedRowCommandType: {
+        assertExternalObjectNewRowProjectCommand(input.command);
+        if (!this.externalObjectNewRowStore) {
+          throw new Error("External object new-row store is not available.");
+        }
+        return this.externalObjectNewRowStore.execute({
+          ...input,
+          command: input.command,
+        }).revision;
+      }
       case projectStateRestoreCommandType: {
         assertProjectStateRestoreCommand(input.command);
         return this.projectStateRestoreStore.execute({

src/server/composition/project-command-stores.ts

@@ -25,6 +25,7 @@ import { ProjectCommandService } from "../../domain/services/project-command.ser
 import { ExternalCsvConfigurationProjectCommandRepository } from "../../db/repositories/external-csv-configuration-project-command.repository.js";
 import { ExternalInitialImportProjectCommandRepository } from "../../db/repositories/external-initial-import-project-command.repository.js";
 import { ExternalObjectRowAssignmentProjectCommandRepository } from "../../db/repositories/external-object-row-assignment-project-command.repository.js";
+import { ExternalObjectNewRowProjectCommandRepository } from "../../db/repositories/external-object-new-row-project-command.repository.js";
 
 export const circuitProjectCommandStore = new CircuitProjectCommandRepository(db);
 export const circuitDeviceRowProjectCommandStore =
@@ -74,6 +75,8 @@ export const externalInitialImportProjectCommandStore =
   new ExternalInitialImportProjectCommandRepository(db);
 export const externalObjectRowAssignmentProjectCommandStore =
   new ExternalObjectRowAssignmentProjectCommandRepository(db);
+export const externalObjectNewRowProjectCommandStore =
+  new ExternalObjectNewRowProjectCommandRepository(db);
 export const projectCommandService = new ProjectCommandService(
   circuitProjectCommandStore,
   circuitDeviceRowProjectCommandStore,
@@ -99,5 +102,6 @@ export const projectCommandService = new ProjectCommandService(
   projectHistoryStore,
   externalCsvConfigurationProjectCommandStore,
   externalInitialImportProjectCommandStore,
-  externalObjectRowAssignmentProjectCommandStore
+  externalObjectRowAssignmentProjectCommandStore,
+  externalObjectNewRowProjectCommandStore
 );