Add real SQLite transaction tests

docs/spec/07-implementation-phases-todo.md

@@ -322,6 +322,13 @@ Acceptance criteria:
 - domain command behavior is not coupled to `better-sqlite3`
 - adding a PostgreSQL persistence adapter does not require rewriting editor domain rules
 
+Implemented foundation:
+
+- database contexts can be created independently from the production singleton
+- SQLite foreign-key enforcement is enabled explicitly for every context
+- the distribution-board repository receives its database dependency explicitly
+- distribution-board setup has real in-memory SQLite commit and rollback coverage using production migrations
+
 ## Phase 12: Project Revisions and Persistent Undo / Redo
 
 Goal:

src/db/client.ts

@@ -1,13 +1,9 @@
-import fs from "node:fs";
 import path from "node:path";
-import Database from "better-sqlite3";
+import { createDatabaseContext } from "./database-context.js";
-import { drizzle } from "drizzle-orm/better-sqlite3";
 
-const dataDir = path.resolve("data");
+const defaultDatabaseContext = createDatabaseContext(
-if (!fs.existsSync(dataDir)) {
+  path.resolve("data", "leistungsbilanz.db")
-  fs.mkdirSync(dataDir, { recursive: true });
+);
-}
 
-const sqlite = new Database(path.resolve(dataDir, "leistungsbilanz.db"));
+export const db = defaultDatabaseContext.db;
-export const db = drizzle(sqlite);
 

src/db/database-context.ts

@@ -0,0 +1,33 @@
+import fs from "node:fs";
+import path from "node:path";
+import Database from "better-sqlite3";
+import {
+  drizzle,
+  type BetterSQLite3Database,
+} from "drizzle-orm/better-sqlite3";
+
+export interface DatabaseContext {
+  db: BetterSQLite3Database;
+  sqlite: Database.Database;
+  close: () => void;
+}
+
+export type AppDatabase = DatabaseContext["db"];
+
+export function createDatabaseContext(filename: string): DatabaseContext {
+  if (filename !== ":memory:") {
+    const parentDirectory = path.dirname(path.resolve(filename));
+    if (!fs.existsSync(parentDirectory)) {
+      fs.mkdirSync(parentDirectory, { recursive: true });
+    }
+  }
+
+  const sqlite = new Database(filename);
+  sqlite.pragma("foreign_keys = ON");
+  const database = drizzle(sqlite);
+  return {
+    db: database,
+    sqlite,
+    close: () => sqlite.close(),
+  };
+}

src/db/repositories/distribution-board.repository.ts

@@ -1,20 +1,25 @@
 import crypto from "node:crypto";
 import { and, eq } from "drizzle-orm";
-import { db } from "../client.js";
+import type { AppDatabase } from "../database-context.js";
 import { circuitLists } from "../schema/circuit-lists.js";
 import { circuitSections } from "../schema/circuit-sections.js";
 import { distributionBoards } from "../schema/distribution-boards.js";
 import { createDefaultCircuitSectionValues } from "./circuit-section.repository.js";
 
 export class DistributionBoardRepository {
+  constructor(private readonly database: AppDatabase) {}
+
   async listByProject(projectId: string) {
-    return db.select().from(distributionBoards).where(eq(distributionBoards.projectId, projectId));
+    return this.database
+      .select()
+      .from(distributionBoards)
+      .where(eq(distributionBoards.projectId, projectId));
   }
 
   async create(projectId: string, name: string) {
     const id = crypto.randomUUID();
     const board = { id, projectId, name };
-    await db.insert(distributionBoards).values(board);
+    await this.database.insert(distributionBoards).values(board);
     return board;
   }
 
@@ -29,7 +34,7 @@ export class DistributionBoardRepository {
     };
     const sections = createDefaultCircuitSectionValues(id);
 
-    db.transaction((tx) => {
+    this.database.transaction((tx) => {
       tx.insert(distributionBoards).values(board).run();
       tx.insert(circuitLists).values(circuitList).run();
       tx.insert(circuitSections).values(sections).run();
@@ -39,7 +44,7 @@ export class DistributionBoardRepository {
   }
 
   async existsInProject(projectId: string, distributionBoardId: string) {
-    const [row] = await db
+    const [row] = await this.database
       .select({ id: distributionBoards.id })
       .from(distributionBoards)
       .where(

src/server/controllers/consumer.controller.ts

@@ -1,4 +1,5 @@
 import type { Request, Response } from "express";
+import { db } from "../../db/client.js";
 import { CircuitListRepository } from "../../db/repositories/circuit-list.repository.js";
 import { ConsumerRepository } from "../../db/repositories/consumer.repository.js";
 import { DistributionBoardRepository } from "../../db/repositories/distribution-board.repository.js";
@@ -17,7 +18,7 @@ import {
 
 const circuitListRepository = new CircuitListRepository();
 const consumerRepository = new ConsumerRepository();
-const distributionBoardRepository = new DistributionBoardRepository();
+const distributionBoardRepository = new DistributionBoardRepository(db);
 const floorRepository = new FloorRepository();
 const projectDeviceRepository = new ProjectDeviceRepository();
 const projectRepository = new ProjectRepository();

src/server/controllers/distribution-board.controller.ts

@@ -1,8 +1,9 @@
 import type { Request, Response } from "express";
+import { db } from "../../db/client.js";
 import { DistributionBoardRepository } from "../../db/repositories/distribution-board.repository.js";
 import { createDistributionBoardSchema } from "../../shared/validation/consumer.schemas.js";
 
-const distributionBoardRepository = new DistributionBoardRepository();
+const distributionBoardRepository = new DistributionBoardRepository(db);
 
 export async function listDistributionBoardsByProject(req: Request, res: Response) {
   const { projectId } = req.params;

tests/distribution-board.repository.test.ts

@@ -1,62 +1,60 @@
+import path from "node:path";
 import assert from "node:assert/strict";
 import { describe, it } from "node:test";
-import { db } from "../src/db/client.js";
+import { eq } from "drizzle-orm";
+import { migrate } from "drizzle-orm/better-sqlite3/migrator";
+import {
+  createDatabaseContext,
+  type DatabaseContext,
+} from "../src/db/database-context.js";
 import { DistributionBoardRepository } from "../src/db/repositories/distribution-board.repository.js";
 import { circuitLists } from "../src/db/schema/circuit-lists.js";
 import { circuitSections } from "../src/db/schema/circuit-sections.js";
 import { distributionBoards } from "../src/db/schema/distribution-boards.js";
+import { projects } from "../src/db/schema/projects.js";
 
-describe("distribution board repository", () => {
+function createTestDatabase(): DatabaseContext {
-  it("creates board, circuit list and default sections in one synchronous transaction", () => {
+  const context = createDatabaseContext(":memory:");
-    const originalTransaction = db.transaction;
+  migrate(context.db, {
-    const insertedValues: Array<{ table: unknown; values: unknown }> = [];
+    migrationsFolder: path.resolve("src", "db", "migrations"),
-    let transactionCalls = 0;
+  });
-
+  context.db.insert(projects).values({ id: "project-1", name: "Test project" }).run();
-    (db as unknown as { transaction: (callback: (tx: unknown) => unknown) => unknown }).transaction =
+  return context;
-      (callback) => {
+}
-        transactionCalls += 1;
-        return callback({
-          insert(table: unknown) {
-            return {
-              values(values: unknown) {
-                insertedValues.push({ table, values });
-                return {
-                  run() {
-                    return { changes: Array.isArray(values) ? values.length : 1 };
-                  },
-                };
-              },
-            };
-          },
-        });
-      };
 
+describe("distribution board repository integration", () => {
+  it("commits board, circuit list and default sections together", () => {
+    const context = createTestDatabase();
     try {
-      const repository = new DistributionBoardRepository();
+      const repository = new DistributionBoardRepository(context.db);
-      const board = repository.createWithCircuitListAndDefaultSections("p1", "UV-01");
+      const board = repository.createWithCircuitListAndDefaultSections(
+        "project-1",
+        "UV-01"
+      );
 
-      assert.equal(transactionCalls, 1);
+      const persistedBoards = context.db
-      assert.equal(insertedValues.length, 3);
+        .select()
-      assert.equal(insertedValues[0].table, distributionBoards);
+        .from(distributionBoards)
-      assert.deepEqual(insertedValues[0].values, board);
+        .where(eq(distributionBoards.id, board.id))
-      assert.equal(insertedValues[1].table, circuitLists);
+        .all();
-      assert.deepEqual(insertedValues[1].values, {
+      const persistedLists = context.db
-        id: board.id,
+        .select()
-        projectId: "p1",
+        .from(circuitLists)
-        distributionBoardId: board.id,
+        .where(eq(circuitLists.distributionBoardId, board.id))
-        name: "UV-01 Stromkreisliste",
+        .all();
-      });
+      const persistedSections = context.db
-      assert.equal(insertedValues[2].table, circuitSections);
+        .select()
+        .from(circuitSections)
+        .where(eq(circuitSections.circuitListId, board.id))
+        .all();
 
-      const sections = insertedValues[2].values as Array<{
+      assert.deepEqual(persistedBoards, [board]);
-        circuitListId: string;
+      assert.equal(persistedLists.length, 1);
-        key: string;
+      assert.equal(persistedLists[0].name, "UV-01 Stromkreisliste");
-        prefix: string;
-      }>;
-      assert.equal(sections.length, 4);
-      assert.ok(sections.every((section) => section.circuitListId === board.id));
       assert.deepEqual(
-        sections.map((section) => [section.key, section.prefix]),
+        persistedSections
+          .sort((left, right) => left.sortOrder - right.sortOrder)
+          .map((section) => [section.key, section.prefix]),
         [
           ["lighting", "-1F"],
           ["single_phase", "-2F"],
@@ -65,7 +63,36 @@ describe("distribution board repository", () => {
         ]
       );
     } finally {
-      (db as unknown as { transaction: unknown }).transaction = originalTransaction;
+      context.close();
+    }
+  });
+
+  it("rolls back board and circuit list when default section creation fails", () => {
+    const context = createTestDatabase();
+    try {
+      context.sqlite.exec(`
+        CREATE TRIGGER fail_default_section_insert
+        BEFORE INSERT ON circuit_sections
+        BEGIN
+          SELECT RAISE(ABORT, 'forced section failure');
+        END;
+      `);
+      const repository = new DistributionBoardRepository(context.db);
+
+      assert.throws(
+        () =>
+          repository.createWithCircuitListAndDefaultSections(
+            "project-1",
+            "UV rollback"
+          ),
+        /forced section failure/
+      );
+
+      assert.equal(context.db.select().from(distributionBoards).all().length, 0);
+      assert.equal(context.db.select().from(circuitLists).all().length, 0);
+      assert.equal(context.db.select().from(circuitSections).all().length, 0);
+    } finally {
+      context.close();
     }
   });
 });