jappel/leistungsbilanz-ts
0
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add circuit reorder history

Browse Source
This commit is contained in:
Julian Appel
2026-07-24 08:21:32 +02:00
parent 53282e8c7c
commit 332dfdb5d9
14 changed files with 865 additions and 16 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tests/circuit-section-reorder-project-command.repository.test.ts
+391
View File
@@ -0,0 +1,391 @@
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 { CircuitSectionReorderProjectCommandRepository } from "../src/db/repositories/circuit-section-reorder-project-command.repository.js";
import { DistributionBoardRepository } from "../src/db/repositories/distribution-board.repository.js";
import { ProjectHistoryRepository } from "../src/db/repositories/project-history.repository.js";
import { circuitDeviceRows } from "../src/db/schema/circuit-device-rows.js";
import { circuitSections } from "../src/db/schema/circuit-sections.js";
import { circuits } from "../src/db/schema/circuits.js";
import { projectRevisions } from "../src/db/schema/project-revisions.js";
import { projects } from "../src/db/schema/projects.js";
import { createCircuitSectionReorderProjectCommand } from "../src/domain/models/circuit-section-reorder-project-command.model.js";
interface TestFixture {
context: DatabaseContext;
sectionId: string;
foreignSectionId: string;
}
function createTestDatabase(): TestFixture {
const context = createDatabaseContext(":memory:");
migrate(context.db, {
migrationsFolder: path.resolve("src", "db", "migrations"),
});
context.db
.insert(projects)
.values([
{ id: "project-1", name: "Test project" },
{ id: "project-2", name: "Other project" },
])
.run();
const boards = new DistributionBoardRepository(context.db);
const board = boards.createWithCircuitListAndDefaultSections(
"project-1",
"UV-01"
);
const foreignBoard = boards.createWithCircuitListAndDefaultSections(
"project-2",
"UV-02"
);
const section = context.db
.select()
.from(circuitSections)
.where(eq(circuitSections.circuitListId, board.id))
.get();
const foreignSection = context.db
.select()
.from(circuitSections)
.where(eq(circuitSections.circuitListId, foreignBoard.id))
.get();
assert.ok(section);
assert.ok(foreignSection);
context.db
.insert(circuits)
.values([
{
id: "circuit-1",
circuitListId: board.id,
sectionId: section.id,
equipmentIdentifier: "-1F1",
sortOrder: 10,
},
{
id: "circuit-2",
circuitListId: board.id,
sectionId: section.id,
equipmentIdentifier: "-1F2",
sortOrder: 20,
},
{
id: "circuit-3",
circuitListId: board.id,
sectionId: section.id,
equipmentIdentifier: "-1F3",
sortOrder: 30,
},
{
id: "circuit-foreign",
circuitListId: foreignBoard.id,
sectionId: foreignSection.id,
equipmentIdentifier: "-1F1",
sortOrder: 10,
},
])
.run();
context.db
.insert(circuitDeviceRows)
.values({
id: "row-1",
circuitId: "circuit-1",
sortOrder: 10,
name: "Leuchte",
displayName: "Leuchte",
quantity: 1,
powerPerUnit: 0.1,
simultaneityFactor: 1,
})
.run();
return {
context,
sectionId: section.id,
foreignSectionId: foreignSection.id,
};
}
function getCircuitState(context: DatabaseContext) {
return context.db
.select({
id: circuits.id,
equipmentIdentifier: circuits.equipmentIdentifier,
sortOrder: circuits.sortOrder,
})
.from(circuits)
.all()
.filter((circuit) => circuit.id !== "circuit-foreign")
.sort((left, right) => left.id.localeCompare(right.id));
}
function createReorderCommand(sectionId: string) {
return createCircuitSectionReorderProjectCommand(sectionId, [
{
circuitId: "circuit-1",
expectedSortOrder: 10,
targetSortOrder: 20,
},
{
circuitId: "circuit-2",
expectedSortOrder: 20,
targetSortOrder: 30,
},
{
circuitId: "circuit-3",
expectedSortOrder: 30,
targetSortOrder: 10,
},
]);
}
describe("circuit section reorder project-command repository", () => {
it("reorders a complete section and supports persisted undo and redo", () => {
const fixture = createTestDatabase();
try {
const store =
new CircuitSectionReorderProjectCommandRepository(
fixture.context.db
);
const command = createReorderCommand(fixture.sectionId);
const reordered = store.execute({
projectId: "project-1",
expectedRevision: 0,
source: "user",
command,
});
assert.deepEqual(getCircuitState(fixture.context), [
{
id: "circuit-1",
equipmentIdentifier: "-1F1",
sortOrder: 20,
},
{
id: "circuit-2",
equipmentIdentifier: "-1F2",
sortOrder: 30,
},
{
id: "circuit-3",
equipmentIdentifier: "-1F3",
sortOrder: 10,
},
]);
assert.equal(
fixture.context.db
.select()
.from(circuitDeviceRows)
.where(eq(circuitDeviceRows.id, "row-1"))
.get()?.circuitId,
"circuit-1"
);
store.execute({
projectId: "project-1",
expectedRevision: 1,
source: "undo",
historyTargetChangeSetId:
reordered.revision.changeSetId,
command: reordered.inverse,
});
assert.deepEqual(
getCircuitState(fixture.context).map(
(circuit) => circuit.sortOrder
),
[10, 20, 30]
);
store.execute({
projectId: "project-1",
expectedRevision: 2,
source: "redo",
historyTargetChangeSetId:
reordered.revision.changeSetId,
command,
});
assert.deepEqual(
new ProjectHistoryRepository(fixture.context.db).getState(
"project-1"
),
{
projectId: "project-1",
currentRevision: 3,
undoDepth: 1,
redoDepth: 0,
undoChangeSetId: reordered.revision.changeSetId,
redoChangeSetId: null,
}
);
} finally {
fixture.context.close();
}
});
it("rejects incomplete, stale and foreign-section reorders", () => {
const fixture = createTestDatabase();
try {
const store =
new CircuitSectionReorderProjectCommandRepository(
fixture.context.db
);
assert.throws(
() =>
store.execute({
projectId: "project-1",
expectedRevision: 0,
source: "user",
command: createCircuitSectionReorderProjectCommand(
fixture.sectionId,
[
{
circuitId: "circuit-1",
expectedSortOrder: 10,
targetSortOrder: 20,
},
{
circuitId: "circuit-2",
expectedSortOrder: 20,
targetSortOrder: 10,
},
]
),
}),
/every circuit/
);
assert.throws(
() =>
store.execute({
projectId: "project-1",
expectedRevision: 0,
source: "user",
command: createCircuitSectionReorderProjectCommand(
fixture.sectionId,
[
{
circuitId: "circuit-1",
expectedSortOrder: 999,
targetSortOrder: 20,
},
{
circuitId: "circuit-2",
expectedSortOrder: 20,
targetSortOrder: 30,
},
{
circuitId: "circuit-3",
expectedSortOrder: 30,
targetSortOrder: 10,
},
]
),
}),
/changed before/
);
assert.throws(
() =>
store.execute({
projectId: "project-1",
expectedRevision: 0,
source: "user",
command: createCircuitSectionReorderProjectCommand(
fixture.foreignSectionId,
[
{
circuitId: "circuit-foreign",
expectedSortOrder: 10,
targetSortOrder: 20,
},
]
),
}),
/does not belong to project/
);
assert.deepEqual(
getCircuitState(fixture.context).map(
(circuit) => circuit.sortOrder
),
[10, 20, 30]
);
assert.equal(
fixture.context.db.select().from(projectRevisions).all()
.length,
0
);
} finally {
fixture.context.close();
}
});
it("rolls back all sort positions for late history failures", () => {
const fixture = createTestDatabase();
try {
fixture.context.sqlite.exec(`
CREATE TRIGGER fail_reorder_history
BEFORE INSERT ON project_history_stack_entries
BEGIN
SELECT RAISE(ABORT, 'forced reorder history failure');
END;
`);
const store =
new CircuitSectionReorderProjectCommandRepository(
fixture.context.db
);
assert.throws(
() =>
store.execute({
projectId: "project-1",
expectedRevision: 0,
source: "user",
command: createReorderCommand(fixture.sectionId),
}),
/forced reorder history failure/
);
assert.deepEqual(
getCircuitState(fixture.context).map(
(circuit) => circuit.sortOrder
),
[10, 20, 30]
);
assert.equal(
fixture.context.db.select().from(projectRevisions).all()
.length,
0
);
} finally {
fixture.context.close();
}
});
it("rolls back the reorder for a stale project revision", () => {
const fixture = createTestDatabase();
try {
const store =
new CircuitSectionReorderProjectCommandRepository(
fixture.context.db
);
assert.throws(
() =>
store.execute({
projectId: "project-1",
expectedRevision: 1,
source: "user",
command: createReorderCommand(fixture.sectionId),
}),
/at revision 0, expected 1/
);
assert.deepEqual(
getCircuitState(fixture.context).map(
(circuit) => circuit.sortOrder
),
[10, 20, 30]
);
} finally {
fixture.context.close();
}
});
});
tests/project-command.model.test.ts
+62
View File
@@ -29,6 +29,10 @@ import {
createCircuitDeleteProjectCommand,
createCircuitInsertProjectCommand,
} from "../src/domain/models/circuit-structure-project-command.model.js";
import {
assertCircuitSectionReorderProjectCommand,
createCircuitSectionReorderProjectCommand,
} from "../src/domain/models/circuit-section-reorder-project-command.model.js";
describe("serialized project commands", () => {
it("round-trips a versioned command envelope", () => {
@@ -519,3 +523,61 @@ describe("circuit structure project commands", () => {
);
});
});
describe("circuit section reorder project commands", () => {
it("captures every expected and target sort position", () => {
const command = createCircuitSectionReorderProjectCommand(
"section-1",
[
{
circuitId: "circuit-1",
expectedSortOrder: 10,
targetSortOrder: 20,
},
{
circuitId: "circuit-2",
expectedSortOrder: 20,
targetSortOrder: 10,
},
]
);
assert.equal(command.payload.assignments.length, 2);
assert.doesNotThrow(() =>
assertCircuitSectionReorderProjectCommand(command)
);
});
it("rejects empty, duplicate and complete no-op assignments", () => {
assert.throws(
() => createCircuitSectionReorderProjectCommand("", []),
/sectionId/
);
assert.throws(
() =>
createCircuitSectionReorderProjectCommand("section-1", [
{
circuitId: "circuit-1",
expectedSortOrder: 10,
targetSortOrder: 20,
},
{
circuitId: "circuit-1",
expectedSortOrder: 20,
targetSortOrder: 10,
},
]),
/duplicate circuit ids/
);
assert.throws(
() =>
createCircuitSectionReorderProjectCommand("section-1", [
{
circuitId: "circuit-1",
expectedSortOrder: 10,
targetSortOrder: 10,
},
]),
/change at least one position/
);
});
});
tests/project-command.service.test.ts
+88
View File
@@ -11,6 +11,7 @@ import { CircuitDeviceRowProjectCommandRepository } from "../src/db/repositories
import { CircuitDeviceRowMoveProjectCommandRepository } from "../src/db/repositories/circuit-device-row-move-project-command.repository.js";
import { CircuitDeviceRowStructureProjectCommandRepository } from "../src/db/repositories/circuit-device-row-structure-project-command.repository.js";
import { CircuitProjectCommandRepository } from "../src/db/repositories/circuit-project-command.repository.js";
import { CircuitSectionReorderProjectCommandRepository } from "../src/db/repositories/circuit-section-reorder-project-command.repository.js";
import { CircuitStructureProjectCommandRepository } from "../src/db/repositories/circuit-structure-project-command.repository.js";
import { DistributionBoardRepository } from "../src/db/repositories/distribution-board.repository.js";
import { ProjectHistoryRepository } from "../src/db/repositories/project-history.repository.js";
@@ -29,6 +30,7 @@ import {
} from "../src/domain/models/circuit-device-row-move-project-command.model.js";
import { createCircuitDeviceRowInsertProjectCommand } from "../src/domain/models/circuit-device-row-structure-project-command.model.js";
import { createCircuitUpdateProjectCommand } from "../src/domain/models/circuit-project-command.model.js";
import { createCircuitSectionReorderProjectCommand } from "../src/domain/models/circuit-section-reorder-project-command.model.js";
import { createCircuitInsertProjectCommand } from "../src/domain/models/circuit-structure-project-command.model.js";
import { ProjectCommandService } from "../src/domain/services/project-command.service.js";
@@ -84,6 +86,7 @@ function createService(context: DatabaseContext) {
new CircuitDeviceRowStructureProjectCommandRepository(context.db),
new CircuitDeviceRowMoveProjectCommandRepository(context.db),
new CircuitStructureProjectCommandRepository(context.db),
new CircuitSectionReorderProjectCommandRepository(context.db),
new ProjectHistoryRepository(context.db)
);
}
@@ -475,6 +478,91 @@ describe("project command service", () => {
}
});
it("dispatches complete section reorders without changing identifiers", () => {
const context = createTestDatabase();
try {
const firstCircuit = context.db
.select()
.from(circuits)
.where(eq(circuits.id, "circuit-1"))
.get();
assert.ok(firstCircuit);
context.db
.insert(circuits)
.values({
id: "circuit-2",
circuitListId: firstCircuit.circuitListId,
sectionId: firstCircuit.sectionId,
equipmentIdentifier: "-1F2",
sortOrder: 20,
isReserve: 1,
})
.run();
const reordered = createService(context).executeUser({
projectId: "project-1",
expectedRevision: 0,
command: createCircuitSectionReorderProjectCommand(
firstCircuit.sectionId,
[
{
circuitId: "circuit-1",
expectedSortOrder: 10,
targetSortOrder: 20,
},
{
circuitId: "circuit-2",
expectedSortOrder: 20,
targetSortOrder: 10,
},
]
),
});
assert.equal(reordered.history.undoDepth, 1);
assert.deepEqual(
context.db
.select({
id: circuits.id,
equipmentIdentifier: circuits.equipmentIdentifier,
sortOrder: circuits.sortOrder,
})
.from(circuits)
.all()
.sort((left, right) => left.id.localeCompare(right.id)),
[
{
id: "circuit-1",
equipmentIdentifier: "-1F1",
sortOrder: 20,
},
{
id: "circuit-2",
equipmentIdentifier: "-1F2",
sortOrder: 10,
},
]
);
createService(context).undo({
projectId: "project-1",
expectedRevision: 1,
});
assert.deepEqual(
context.db
.select({ id: circuits.id, sortOrder: circuits.sortOrder })
.from(circuits)
.all()
.sort((left, right) => left.id.localeCompare(right.id)),
[
{ id: "circuit-1", sortOrder: 10 },
{ id: "circuit-2", sortOrder: 20 },
]
);
} finally {
context.close();
}
});
it("rejects unavailable history directions without writing a revision", () => {
const context = createTestDatabase();
try {