Persist Revit CSV configuration

tests/external-csv-configuration-project-command.repository.test.ts

@@ -0,0 +1,226 @@
+import path from "node:path";
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { eq } from "drizzle-orm";
+import { migrate } from "drizzle-orm/better-sqlite3/migrator";
+import {
+  createDatabaseContext,
+  type DatabaseContext,
+} from "../src/db/database-context.js";
+import { ExternalCsvConfigurationProjectCommandRepository } from "../src/db/repositories/external-csv-configuration-project-command.repository.js";
+import { ProjectTransferRepository } from "../src/db/repositories/project-transfer.repository.js";
+import { ProjectStateRestoreCommandRepository } from "../src/db/repositories/project-state-restore-command.repository.js";
+import { readProjectStateSnapshot } from "../src/db/repositories/project-state-snapshot.persistence.js";
+import { externalCsvConfigurations } from "../src/db/schema/external-csv-configurations.js";
+import { projects } from "../src/db/schema/projects.js";
+import { createExternalCsvConfigurationUpdateProjectCommand } from "../src/domain/models/external-csv-configuration-project-command.model.js";
+import { createProjectStateRestoreCommand } from "../src/domain/models/project-state-restore-command.model.js";
+import { createDefaultExternalCsvConfiguration } from "../src/external-model/csv/external-csv-contracts.js";
+import { externalCsvTestColumns } from "./fixtures/revit-csv-fixtures.js";
+
+function createTestDatabase(): DatabaseContext {
+  const context = createDatabaseContext(":memory:");
+  migrate(context.db, {
+    migrationsFolder: path.resolve("src", "db", "migrations"),
+  });
+  context.db.insert(projects).values({ id: "project-1", name: "Projekt" }).run();
+  return context;
+}
+
+function snapshot(version = 1) {
+  const configuration = createDefaultExternalCsvConfiguration(externalCsvTestColumns);
+  configuration.familyTypeRules.push({
+    exactFamilyAndType: "Steckdose: Standard",
+    internalDeviceType: "Steckdose",
+    connectionKind: null,
+    category: "single_phase",
+    quantityRule: { kind: "fixed", quantity: 1 },
+    displayNameSuggestion: { kind: "selection-marker" },
+  });
+  return {
+    id: "external-config-1",
+    projectId: "project-1",
+    configurationVersion: version,
+    configuration,
+  };
+}
+
+describe("external CSV configuration project command", () => {
+  it("persists insert and update with exact inverse commands", () => {
+    const context = createTestDatabase();
+    try {
+      const repository = new ExternalCsvConfigurationProjectCommandRepository(context.db);
+      const initial = snapshot();
+      const inserted = repository.execute({
+        projectId: "project-1",
+        expectedRevision: 0,
+        source: "user",
+        description: "Revit-CSV-Konfiguration anlegen",
+        command: createExternalCsvConfigurationUpdateProjectCommand(null, initial),
+      });
+      assert.equal(inserted.revision.revisionNumber, 1);
+      assert.deepEqual(readConfiguration(context), initial);
+      assert.deepEqual(inserted.inverse.payload, { expected: initial, target: null });
+
+      const target = structuredClone(initial);
+      target.configurationVersion = 2;
+      target.configuration.decimalSeparator = ".";
+      const updated = repository.execute({
+        projectId: "project-1",
+        expectedRevision: 1,
+        source: "user",
+        command: createExternalCsvConfigurationUpdateProjectCommand(initial, target),
+      });
+      assert.equal(updated.revision.revisionNumber, 2);
+      assert.deepEqual(readConfiguration(context), target);
+      assert.deepEqual(updated.inverse.payload, { expected: target, target: initial });
+    } finally {
+      context.close();
+    }
+  });
+
+  it("rejects stale state and cross-project targets without a partial revision", () => {
+    const context = createTestDatabase();
+    try {
+      const repository = new ExternalCsvConfigurationProjectCommandRepository(context.db);
+      const initial = snapshot();
+      repository.execute({
+        projectId: "project-1",
+        expectedRevision: 0,
+        source: "user",
+        command: createExternalCsvConfigurationUpdateProjectCommand(null, initial),
+      });
+
+      assert.throws(
+        () => repository.execute({
+          projectId: "project-1",
+          expectedRevision: 1,
+          source: "user",
+          command: createExternalCsvConfigurationUpdateProjectCommand(null, snapshot(2)),
+        }),
+        /changed before update/
+      );
+      const foreign = snapshot(2);
+      foreign.projectId = "project-2";
+      assert.throws(
+        () => repository.execute({
+          projectId: "project-1",
+          expectedRevision: 1,
+          source: "user",
+          command: createExternalCsvConfigurationUpdateProjectCommand(initial, foreign),
+        }),
+        /identity must remain stable|different project/
+      );
+      assert.equal(context.db.select({ revision: projects.currentRevision }).from(projects).get()?.revision, 1);
+
+      const skippedVersion = snapshot(3);
+      assert.throws(
+        () => repository.execute({
+          projectId: "project-1",
+          expectedRevision: 1,
+          source: "user",
+          command: createExternalCsvConfigurationUpdateProjectCommand(initial, skippedVersion),
+        }),
+        /version must advance by one/
+      );
+      assert.throws(
+        () => repository.execute({
+          projectId: "project-1",
+          expectedRevision: 1,
+          source: "user",
+          command: createExternalCsvConfigurationUpdateProjectCommand(initial, initial),
+        }),
+        /did not change/
+      );
+    } finally {
+      context.close();
+    }
+  });
+
+  it("includes configuration in snapshots and remaps it for project duplicates", () => {
+    const context = createTestDatabase();
+    try {
+      const repository = new ExternalCsvConfigurationProjectCommandRepository(context.db);
+      const initial = snapshot();
+      repository.execute({
+        projectId: "project-1",
+        expectedRevision: 0,
+        source: "user",
+        command: createExternalCsvConfigurationUpdateProjectCommand(null, initial),
+      });
+
+      const state = readProjectStateSnapshot(context.db, "project-1")?.state;
+      assert.deepEqual(state?.externalCsvConfiguration, initial);
+      const transferRepository = new ProjectTransferRepository(context.db);
+      const transfer = transferRepository.exportProject("project-1");
+      assert.ok(transfer);
+      const duplicate = transferRepository.importDuplicate(transfer);
+      const duplicatedConfiguration = context.db
+        .select()
+        .from(externalCsvConfigurations)
+        .where(eq(externalCsvConfigurations.projectId, duplicate.projectId))
+        .get();
+      assert.ok(duplicatedConfiguration);
+      assert.notEqual(duplicatedConfiguration.id, initial.id);
+      assert.equal(duplicatedConfiguration.projectId, duplicate.projectId);
+      assert.deepEqual(duplicatedConfiguration.configuration, initial.configuration);
+    } finally {
+      context.close();
+    }
+  });
+
+  it("restores and undoes the complete configuration through snapshot history", () => {
+    const context = createTestDatabase();
+    try {
+      const configurationRepository = new ExternalCsvConfigurationProjectCommandRepository(context.db);
+      const initial = snapshot();
+      configurationRepository.execute({
+        projectId: "project-1",
+        expectedRevision: 0,
+        source: "user",
+        command: createExternalCsvConfigurationUpdateProjectCommand(null, initial),
+      });
+      const configuredState = readProjectStateSnapshot(context.db, "project-1");
+      assert.ok(configuredState);
+      configurationRepository.execute({
+        projectId: "project-1",
+        expectedRevision: 1,
+        source: "user",
+        command: createExternalCsvConfigurationUpdateProjectCommand(initial, null),
+      });
+      const emptyState = readProjectStateSnapshot(context.db, "project-1");
+      assert.ok(emptyState);
+
+      const restoreRepository = new ProjectStateRestoreCommandRepository(context.db);
+      const restored = restoreRepository.execute({
+        projectId: "project-1",
+        expectedRevision: 2,
+        source: "user",
+        command: createProjectStateRestoreCommand(
+          emptyState.payloadSha256,
+          configuredState.state
+        ),
+      });
+      assert.deepEqual(readConfiguration(context), initial);
+
+      restoreRepository.execute({
+        projectId: "project-1",
+        expectedRevision: 3,
+        source: "undo",
+        historyTargetChangeSetId: restored.revision.changeSetId,
+        command: restored.inverse,
+      });
+      assert.equal(readConfiguration(context), null);
+    } finally {
+      context.close();
+    }
+  });
+});
+
+function readConfiguration(context: DatabaseContext) {
+  return context.db
+    .select()
+    .from(externalCsvConfigurations)
+    .where(eq(externalCsvConfigurations.projectId, "project-1"))
+    .get() ?? null;
+}

tests/external-csv-configuration.test.ts

@@ -122,6 +122,14 @@ describe("external CSV configuration", () => {
     configuration.familyTypeRules[0].quantityRule = { kind: "mapped-column" };
     assert.match(validateFailure(configuration), /requires a configured quantity column/);
   });
+
+  it("rejects unknown configuration fields", () => {
+    const configuration = {
+      ...createDefaultExternalCsvConfiguration(columns),
+      legacyMapping: true,
+    };
+    assert.match(validateFailure(configuration), /unknown or missing fields/);
+  });
 });
 
 function validateFailure(value: unknown) {

tests/project-command.service.test.ts

@@ -30,6 +30,7 @@ import { ProjectDeviceRowSyncProjectCommandRepository } from "../src/db/reposito
 import { ProjectDeviceStructureProjectCommandRepository } from "../src/db/repositories/project-device-structure-project-command.repository.js";
 import { ProjectStateRestoreCommandRepository } from "../src/db/repositories/project-state-restore-command.repository.js";
 import { ProjectSettingsProjectCommandRepository } from "../src/db/repositories/project-settings-project-command.repository.js";
+import { ExternalCsvConfigurationProjectCommandRepository } from "../src/db/repositories/external-csv-configuration-project-command.repository.js";
 import { circuitDeviceRows } from "../src/db/schema/circuit-device-rows.js";
 import { circuitProtectionDevices } from "../src/db/schema/circuit-protection-devices.js";
 import { circuitSections } from "../src/db/schema/circuit-sections.js";
@@ -42,6 +43,7 @@ import { projectRevisions } from "../src/db/schema/project-revisions.js";
 import { projects } from "../src/db/schema/projects.js";
 import { floors } from "../src/db/schema/floors.js";
 import { rooms } from "../src/db/schema/rooms.js";
+import { externalCsvConfigurations } from "../src/db/schema/external-csv-configurations.js";
 import { createCircuitProtectionUpdateProjectCommand } from "../src/domain/models/circuit-protection-project-command.model.js";
 import { ProjectHistoryOperationUnavailableError } from "../src/domain/errors/project-history-operation-unavailable.error.js";
 import { ProjectRevisionConflictError } from "../src/domain/errors/project-revision-conflict.error.js";
@@ -85,6 +87,9 @@ import { createProjectDeviceRowSyncProjectCommand } from "../src/domain/models/p
 import { createProjectDeviceUpdateProjectCommand } from "../src/domain/models/project-device-project-command.model.js";
 import { createProjectDeviceInsertProjectCommand } from "../src/domain/models/project-device-structure-project-command.model.js";
 import { createProjectSettingsUpdateProjectCommand } from "../src/domain/models/project-settings-project-command.model.js";
+import { createExternalCsvConfigurationUpdateProjectCommand } from "../src/domain/models/external-csv-configuration-project-command.model.js";
+import { createDefaultExternalCsvConfiguration } from "../src/external-model/csv/external-csv-contracts.js";
+import { externalCsvTestColumns } from "./fixtures/revit-csv-fixtures.js";
 import { ProjectCommandService } from "../src/domain/services/project-command.service.js";
 
 function createTestDatabase(): DatabaseContext {
@@ -157,7 +162,8 @@ function createService(context: DatabaseContext) {
     new CircuitGroupMoveProjectCommandRepository(context.db),
     new CircuitGroupSubtreeProjectCommandRepository(context.db),
     new CircuitProtectionProjectCommandRepository(context.db),
-    new ProjectHistoryRepository(context.db)
+    new ProjectHistoryRepository(context.db),
+    new ExternalCsvConfigurationProjectCommandRepository(context.db)
   );
 }
 
@@ -1114,6 +1120,36 @@ describe("project command service", () => {
     }
   });
 
+  it("dispatches external CSV configuration updates through persistent history", () => {
+    const context = createTestDatabase();
+    try {
+      const service = createService(context);
+      const target = {
+        id: "external-config-1",
+        projectId: "project-1",
+        configurationVersion: 1,
+        configuration: createDefaultExternalCsvConfiguration(externalCsvTestColumns),
+      };
+      const updated = service.executeUser({
+        projectId: "project-1",
+        expectedRevision: 0,
+        command: createExternalCsvConfigurationUpdateProjectCommand(null, target),
+      });
+      assert.equal(updated.history.currentRevision, 1);
+      assert.equal(context.db.select().from(externalCsvConfigurations).all().length, 1);
+
+      const undone = service.undo({ projectId: "project-1", expectedRevision: 1 });
+      assert.equal(undone.history.currentRevision, 2);
+      assert.equal(context.db.select().from(externalCsvConfigurations).all().length, 0);
+
+      const redone = service.redo({ projectId: "project-1", expectedRevision: 2 });
+      assert.equal(redone.history.currentRevision, 3);
+      assert.equal(context.db.select().from(externalCsvConfigurations).all().length, 1);
+    } finally {
+      context.close();
+    }
+  });
+
   it("dispatches distribution-board setup and its persisted inverse", () => {
     const context = createTestDatabase();
     try {

tests/project-state-snapshot.test.ts

@@ -31,6 +31,7 @@ function minimalSnapshot() {
       ],
     },
     distributionBoards: [],
+    externalCsvConfiguration: null,
     circuitLists: [],
     circuitSections: [],
     distributionBoardComponents: [],
@@ -147,11 +148,24 @@ describe("project state snapshot model", () => {
     const baseline = structuredClone(minimalSnapshot());
     baseline.schemaVersion = 1 as typeof baseline.schemaVersion;
     delete (baseline.project as Record<string, unknown>).isPublicBuilding;
+    delete (baseline as Record<string, unknown>).externalCsvConfiguration;
 
     const upgraded = parseProjectStateSnapshot(baseline);
 
     assert.equal(upgraded.schemaVersion, projectStateSnapshotSchemaVersion);
     assert.equal(upgraded.project.isPublicBuilding, false);
+    assert.equal(upgraded.externalCsvConfiguration, null);
+  });
+
+  it("upgrades snapshot version 2 with an empty external CSV configuration", () => {
+    const previous = structuredClone(minimalSnapshot());
+    previous.schemaVersion = 2 as typeof previous.schemaVersion;
+    delete (previous as Record<string, unknown>).externalCsvConfiguration;
+
+    const upgraded = parseProjectStateSnapshot(previous);
+
+    assert.equal(upgraded.schemaVersion, projectStateSnapshotSchemaVersion);
+    assert.equal(upgraded.externalCsvConfiguration, null);
   });
 
   it("rejects malformed baseline and unknown snapshot shapes", () => {