Phase 1A done

src/db/repositories/circuit-device-row.repository.ts

@@ -0,0 +1,61 @@
+import crypto from "node:crypto";
+import { asc, inArray } from "drizzle-orm";
+import { db } from "../client.js";
+import { circuitDeviceRows } from "../schema/circuit-device-rows.js";
+
+export class CircuitDeviceRowRepository {
+  async listByCircuitList(circuitIds: string[]) {
+    if (!circuitIds.length) {
+      return [];
+    }
+    return db
+      .select()
+      .from(circuitDeviceRows)
+      .where(inArray(circuitDeviceRows.circuitId, circuitIds))
+      .orderBy(asc(circuitDeviceRows.sortOrder));
+  }
+
+  async create(input: {
+    circuitId: string;
+    linkedProjectDeviceId?: string;
+    legacyConsumerId?: string;
+    sortOrder: number;
+    name: string;
+    displayName: string;
+    phaseType?: string;
+    connectionKind?: string;
+    costGroup?: string;
+    category?: string;
+    roomId?: string;
+    roomNumberSnapshot?: string;
+    roomNameSnapshot?: string;
+    quantity: number;
+    powerPerUnit: number;
+    simultaneityFactor: number;
+    cosPhi?: number;
+    remark?: string;
+  }) {
+    await db.insert(circuitDeviceRows).values({
+      id: crypto.randomUUID(),
+      circuitId: input.circuitId,
+      linkedProjectDeviceId: input.linkedProjectDeviceId ?? null,
+      legacyConsumerId: input.legacyConsumerId ?? null,
+      sortOrder: input.sortOrder,
+      name: input.name,
+      displayName: input.displayName,
+      phaseType: input.phaseType ?? null,
+      connectionKind: input.connectionKind ?? null,
+      costGroup: input.costGroup ?? null,
+      category: input.category ?? null,
+      roomId: input.roomId ?? null,
+      roomNumberSnapshot: input.roomNumberSnapshot ?? null,
+      roomNameSnapshot: input.roomNameSnapshot ?? null,
+      quantity: input.quantity,
+      powerPerUnit: input.powerPerUnit,
+      simultaneityFactor: input.simultaneityFactor,
+      cosPhi: input.cosPhi ?? null,
+      remark: input.remark ?? null,
+      overriddenFields: null,
+    });
+  }
+}

src/db/repositories/circuit-section.repository.ts

@@ -0,0 +1,42 @@
+import crypto from "node:crypto";
+import { and, asc, eq } from "drizzle-orm";
+import { db } from "../client.js";
+import { circuitSections } from "../schema/circuit-sections.js";
+
+export class CircuitSectionRepository {
+  async listByCircuitList(circuitListId: string) {
+    return db
+      .select()
+      .from(circuitSections)
+      .where(eq(circuitSections.circuitListId, circuitListId))
+      .orderBy(asc(circuitSections.sortOrder));
+  }
+
+  async createDefaults(circuitListId: string) {
+    const defaults = [
+      { key: "lighting", displayName: "Lighting", prefix: "-1F", sortOrder: 10 },
+      { key: "single_phase", displayName: "Single-phase circuits", prefix: "-2F", sortOrder: 20 },
+      { key: "three_phase", displayName: "Three-phase circuits", prefix: "-3F", sortOrder: 30 },
+      { key: "unassigned", displayName: "Unassigned", prefix: "-UF", sortOrder: 90 },
+    ];
+
+    for (const entry of defaults) {
+      const existing = await db
+        .select({ id: circuitSections.id })
+        .from(circuitSections)
+        .where(
+          and(eq(circuitSections.circuitListId, circuitListId), eq(circuitSections.key, entry.key))
+        )
+        .limit(1);
+      if (existing.length) {
+        continue;
+      }
+      await db.insert(circuitSections).values({
+        id: crypto.randomUUID(),
+        circuitListId,
+        ...entry,
+      });
+    }
+  }
+}
+

src/db/repositories/circuit.repository.ts

@@ -0,0 +1,50 @@
+import crypto from "node:crypto";
+import { asc, eq } from "drizzle-orm";
+import { db } from "../client.js";
+import { circuits } from "../schema/circuits.js";
+
+export class CircuitRepository {
+  async listByCircuitList(circuitListId: string) {
+    return db
+      .select()
+      .from(circuits)
+      .where(eq(circuits.circuitListId, circuitListId))
+      .orderBy(asc(circuits.sortOrder), asc(circuits.equipmentIdentifier));
+  }
+
+  async create(input: {
+    circuitListId: string;
+    sectionId: string;
+    equipmentIdentifier: string;
+    displayName?: string;
+    sortOrder: number;
+    protectionType?: string;
+    protectionRatedCurrent?: number;
+    protectionCharacteristic?: string;
+    cableType?: string;
+    cableCrossSection?: string;
+    cableLength?: number;
+    voltage?: number;
+    remark?: string;
+  }) {
+    const id = crypto.randomUUID();
+    await db.insert(circuits).values({
+      id,
+      circuitListId: input.circuitListId,
+      sectionId: input.sectionId,
+      equipmentIdentifier: input.equipmentIdentifier,
+      displayName: input.displayName ?? null,
+      sortOrder: input.sortOrder,
+      protectionType: input.protectionType ?? null,
+      protectionRatedCurrent: input.protectionRatedCurrent ?? null,
+      protectionCharacteristic: input.protectionCharacteristic ?? null,
+      cableType: input.cableType ?? null,
+      cableCrossSection: input.cableCrossSection ?? null,
+      cableLength: input.cableLength ?? null,
+      voltage: input.voltage ?? null,
+      remark: input.remark ?? null,
+    });
+    return id;
+  }
+}
+

src/db/repositories/consumer.repository.ts

@@ -12,6 +12,10 @@ export class ConsumerRepository {
     return db.select().from(consumers).where(eq(consumers.projectId, projectId));
   }
 
+  async listByCircuitList(circuitListId: string) {
+    return db.select().from(consumers).where(eq(consumers.circuitListId, circuitListId));
+  }
+
   async create(input: CreateConsumerInput) {
     const id = crypto.randomUUID();
     const normalizedName = input.name?.trim() || "Unbenannter Eintrag";