first commit

src/db/client.ts

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

src/db/migrations/0000_bizarre_colossus.sql

@@ -0,0 +1,28 @@
+CREATE TABLE `consumers` (
+	`id` text PRIMARY KEY NOT NULL,
+	`project_id` text NOT NULL,
+	`distribution_board_id` text,
+	`name` text NOT NULL,
+	`category` text,
+	`quantity` integer NOT NULL,
+	`installed_power_per_unit_kw` real NOT NULL,
+	`demand_factor` real NOT NULL,
+	`voltage_v` real,
+	`phase_count` integer,
+	`power_factor` real,
+	`note` text,
+	FOREIGN KEY (`project_id`) REFERENCES `projects`(`id`) ON UPDATE no action ON DELETE cascade,
+	FOREIGN KEY (`distribution_board_id`) REFERENCES `distribution_boards`(`id`) ON UPDATE no action ON DELETE set null
+);
+--> statement-breakpoint
+CREATE TABLE `distribution_boards` (
+	`id` text PRIMARY KEY NOT NULL,
+	`project_id` text NOT NULL,
+	`name` text NOT NULL,
+	FOREIGN KEY (`project_id`) REFERENCES `projects`(`id`) ON UPDATE no action ON DELETE cascade
+);
+--> statement-breakpoint
+CREATE TABLE `projects` (
+	`id` text PRIMARY KEY NOT NULL,
+	`name` text NOT NULL
+);

src/db/migrations/meta/0000_snapshot.json

@@ -0,0 +1,208 @@
+{
+  "version": "6",
+  "dialect": "sqlite",
+  "id": "d219f155-9dd0-48e3-8fd2-8278f1f788ca",
+  "prevId": "00000000-0000-0000-0000-000000000000",
+  "tables": {
+    "consumers": {
+      "name": "consumers",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "distribution_board_id": {
+          "name": "distribution_board_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "category": {
+          "name": "category",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "quantity": {
+          "name": "quantity",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "installed_power_per_unit_kw": {
+          "name": "installed_power_per_unit_kw",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "demand_factor": {
+          "name": "demand_factor",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "voltage_v": {
+          "name": "voltage_v",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "phase_count": {
+          "name": "phase_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "power_factor": {
+          "name": "power_factor",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "note": {
+          "name": "note",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "consumers_project_id_projects_id_fk": {
+          "name": "consumers_project_id_projects_id_fk",
+          "tableFrom": "consumers",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "consumers_distribution_board_id_distribution_boards_id_fk": {
+          "name": "consumers_distribution_board_id_distribution_boards_id_fk",
+          "tableFrom": "consumers",
+          "tableTo": "distribution_boards",
+          "columnsFrom": [
+            "distribution_board_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "distribution_boards": {
+      "name": "distribution_boards",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "distribution_boards_project_id_projects_id_fk": {
+          "name": "distribution_boards_project_id_projects_id_fk",
+          "tableFrom": "distribution_boards",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "projects": {
+      "name": "projects",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    }
+  },
+  "views": {},
+  "enums": {},
+  "_meta": {
+    "schemas": {},
+    "tables": {},
+    "columns": {}
+  },
+  "internal": {
+    "indexes": {}
+  }
+}

src/db/migrations/meta/_journal.json

@@ -0,0 +1,13 @@
+{
+  "version": "7",
+  "dialect": "sqlite",
+  "entries": [
+    {
+      "idx": 0,
+      "version": "6",
+      "when": 1777565414148,
+      "tag": "0000_bizarre_colossus",
+      "breakpoints": true
+    }
+  ]
+}

src/db/repositories/consumer.repository.ts

@@ -0,0 +1,31 @@
+import crypto from "node:crypto";
+import { eq } from "drizzle-orm";
+import { db } from "../client.js";
+import { consumers } from "../schema/consumers.js";
+import type { CreateConsumerInput } from "../../shared/validation/consumer.schemas.js";
+
+export class ConsumerRepository {
+  async listByProject(projectId: string) {
+    return db.select().from(consumers).where(eq(consumers.projectId, projectId));
+  }
+
+  async create(input: CreateConsumerInput) {
+    const id = crypto.randomUUID();
+    await db.insert(consumers).values({
+      id,
+      projectId: input.projectId,
+      distributionBoardId: input.distributionBoardId ?? null,
+      name: input.name,
+      category: input.category ?? null,
+      quantity: input.quantity,
+      installedPowerPerUnitKw: input.installedPowerPerUnitKw,
+      demandFactor: input.demandFactor,
+      voltageV: input.voltageV ?? null,
+      phaseCount: input.phaseCount ?? null,
+      powerFactor: input.powerFactor ?? null,
+      note: input.note ?? null,
+    });
+    return { id, ...input };
+  }
+}
+

src/db/repositories/project.repository.ts

@@ -0,0 +1,21 @@
+import crypto from "node:crypto";
+import { eq } from "drizzle-orm";
+import { db } from "../client.js";
+import { projects } from "../schema/projects.js";
+
+export class ProjectRepository {
+  async list() {
+    return db.select().from(projects);
+  }
+
+  async create(name: string) {
+    const id = crypto.randomUUID();
+    await db.insert(projects).values({ id, name });
+    return { id, name };
+  }
+
+  async delete(projectId: string) {
+    await db.delete(projects).where(eq(projects.id, projectId));
+  }
+}
+

src/db/schema/consumers.ts

@@ -0,0 +1,23 @@
+import { integer, real, sqliteTable, text } from "drizzle-orm/sqlite-core";
+import { distributionBoards } from "./distribution-boards.js";
+import { projects } from "./projects.js";
+
+export const consumers = sqliteTable("consumers", {
+  id: text("id").primaryKey(),
+  projectId: text("project_id")
+    .notNull()
+    .references(() => projects.id, { onDelete: "cascade" }),
+  distributionBoardId: text("distribution_board_id").references(() => distributionBoards.id, {
+    onDelete: "set null",
+  }),
+  name: text("name").notNull(),
+  category: text("category"),
+  quantity: integer("quantity").notNull(),
+  installedPowerPerUnitKw: real("installed_power_per_unit_kw").notNull(),
+  demandFactor: real("demand_factor").notNull(),
+  voltageV: real("voltage_v"),
+  phaseCount: integer("phase_count"),
+  powerFactor: real("power_factor"),
+  note: text("note"),
+});
+

src/db/schema/distribution-boards.ts

@@ -0,0 +1,11 @@
+import { sqliteTable, text } from "drizzle-orm/sqlite-core";
+import { projects } from "./projects.js";
+
+export const distributionBoards = sqliteTable("distribution_boards", {
+  id: text("id").primaryKey(),
+  projectId: text("project_id")
+    .notNull()
+    .references(() => projects.id, { onDelete: "cascade" }),
+  name: text("name").notNull(),
+});
+

src/db/schema/projects.ts

@@ -0,0 +1,7 @@
+import { sqliteTable, text } from "drizzle-orm/sqlite-core";
+
+export const projects = sqliteTable("projects", {
+  id: text("id").primaryKey(),
+  name: text("name").notNull(),
+});
+

src/domain/calculations/power-calculation.ts

@@ -0,0 +1,29 @@
+export interface PowerInput {
+  quantity: number;
+  installedPowerPerUnitKw: number;
+  demandFactor: number;
+}
+
+export interface CurrentInput {
+  demandPowerKw: number;
+  voltageV: number;
+  phaseCount: 1 | 3;
+  powerFactor: number;
+}
+
+export function calculateInstalledPowerKw(input: PowerInput): number {
+  return input.quantity * input.installedPowerPerUnitKw;
+}
+
+export function calculateDemandPowerKw(input: PowerInput): number {
+  return calculateInstalledPowerKw(input) * input.demandFactor;
+}
+
+export function calculateCurrentA(input: CurrentInput): number {
+  const powerW = input.demandPowerKw * 1000;
+  if (input.phaseCount === 1) {
+    return powerW / (input.voltageV * input.powerFactor);
+  }
+  return powerW / (Math.sqrt(3) * input.voltageV * input.powerFactor);
+}
+

src/domain/models/consumer.model.ts

@@ -0,0 +1,15 @@
+export interface Consumer {
+  id: string;
+  projectId: string;
+  distributionBoardId?: string;
+  name: string;
+  category?: string;
+  quantity: number;
+  installedPowerPerUnitKw: number;
+  demandFactor: number;
+  voltageV?: number;
+  phaseCount?: 1 | 3;
+  powerFactor?: number;
+  note?: string;
+}
+

src/domain/services/power-balance.service.ts

@@ -0,0 +1,45 @@
+import {
+  calculateCurrentA,
+  calculateDemandPowerKw,
+  calculateInstalledPowerKw,
+} from "../calculations/power-calculation.js";
+import type { Consumer } from "../models/consumer.model.js";
+
+export interface ConsumerWithCalculatedValues extends Consumer {
+  installedPowerKw: number;
+  demandPowerKw: number;
+  currentA?: number;
+}
+
+export class PowerBalanceService {
+  enrichConsumer(consumer: Consumer): ConsumerWithCalculatedValues {
+    const installedPowerKw = calculateInstalledPowerKw({
+      quantity: consumer.quantity,
+      installedPowerPerUnitKw: consumer.installedPowerPerUnitKw,
+      demandFactor: consumer.demandFactor,
+    });
+    const demandPowerKw = calculateDemandPowerKw({
+      quantity: consumer.quantity,
+      installedPowerPerUnitKw: consumer.installedPowerPerUnitKw,
+      demandFactor: consumer.demandFactor,
+    });
+
+    let currentA: number | undefined;
+    if (consumer.voltageV && consumer.phaseCount && consumer.powerFactor) {
+      currentA = calculateCurrentA({
+        demandPowerKw,
+        voltageV: consumer.voltageV,
+        phaseCount: consumer.phaseCount,
+        powerFactor: consumer.powerFactor,
+      });
+    }
+
+    return {
+      ...consumer,
+      installedPowerKw,
+      demandPowerKw,
+      currentA,
+    };
+  }
+}
+

src/frontend/components/README.md

@@ -0,0 +1,4 @@
+# Components Placeholder
+
+Reusable UI components for project, distribution board, and consumer tables.
+

src/frontend/pages/README.md

@@ -0,0 +1,5 @@
+# Frontend Placeholder
+
+Frontend implementation will move here in the next step (React/Next.js).
+The backend API, domain logic, and SQLite persistence are now prepared.
+

src/frontend/utils/README.md

@@ -0,0 +1,4 @@
+# Frontend Utils Placeholder
+
+Shared UI utility helpers will be implemented during the Next.js migration step.
+

src/server/controllers/consumer.controller.ts

@@ -0,0 +1,42 @@
+import type { Request, Response } from "express";
+import { ConsumerRepository } from "../../db/repositories/consumer.repository.js";
+import { PowerBalanceService } from "../../domain/services/power-balance.service.js";
+import { createConsumerSchema } from "../../shared/validation/consumer.schemas.js";
+
+const consumerRepository = new ConsumerRepository();
+const powerBalanceService = new PowerBalanceService();
+
+export async function listConsumersByProject(req: Request, res: Response) {
+  const { projectId } = req.params;
+  if (typeof projectId !== "string") {
+    return res.status(400).json({ error: "Invalid projectId" });
+  }
+  const rows = await consumerRepository.listByProject(projectId);
+  const enriched = rows.map((row) =>
+    powerBalanceService.enrichConsumer({
+      id: row.id,
+      projectId: row.projectId,
+      distributionBoardId: row.distributionBoardId ?? undefined,
+      name: row.name,
+      category: row.category ?? undefined,
+      quantity: row.quantity,
+      installedPowerPerUnitKw: row.installedPowerPerUnitKw,
+      demandFactor: row.demandFactor,
+      voltageV: row.voltageV ?? undefined,
+      phaseCount: row.phaseCount === 1 || row.phaseCount === 3 ? row.phaseCount : undefined,
+      powerFactor: row.powerFactor ?? undefined,
+      note: row.note ?? undefined,
+    })
+  );
+  res.json(enriched);
+}
+
+export async function createConsumer(req: Request, res: Response) {
+  const parsed = createConsumerSchema.safeParse(req.body);
+  if (!parsed.success) {
+    return res.status(400).json({ error: parsed.error.flatten() });
+  }
+  const created = await consumerRepository.create(parsed.data);
+  const enriched = powerBalanceService.enrichConsumer(created);
+  return res.status(201).json(enriched);
+}

src/server/controllers/project.controller.ts

@@ -0,0 +1,20 @@
+import type { Request, Response } from "express";
+import { ProjectRepository } from "../../db/repositories/project.repository.js";
+import { createProjectSchema } from "../../shared/validation/consumer.schemas.js";
+
+const projectRepository = new ProjectRepository();
+
+export async function listProjects(_req: Request, res: Response) {
+  const result = await projectRepository.list();
+  res.json(result);
+}
+
+export async function createProject(req: Request, res: Response) {
+  const parsed = createProjectSchema.safeParse(req.body);
+  if (!parsed.success) {
+    return res.status(400).json({ error: parsed.error.flatten() });
+  }
+  const project = await projectRepository.create(parsed.data.name);
+  return res.status(201).json(project);
+}
+

src/server/index.ts

@@ -0,0 +1,23 @@
+import express from "express";
+import { consumerRouter } from "./routes/consumer.routes.js";
+import { projectRouter } from "./routes/project.routes.js";
+import { errorMiddleware } from "./middleware/error.middleware.js";
+
+const app = express();
+const port = Number(process.env.PORT || 3000);
+
+app.use(express.json());
+
+app.get("/health", (_req, res) => {
+  res.json({ ok: true });
+});
+
+app.use("/api/projects", projectRouter);
+app.use("/api/consumers", consumerRouter);
+
+app.use(errorMiddleware);
+
+app.listen(port, () => {
+  console.log(`Server running on http://localhost:${port}`);
+});
+

src/server/middleware/error.middleware.ts

@@ -0,0 +1,12 @@
+import type { NextFunction, Request, Response } from "express";
+
+export function errorMiddleware(
+  error: unknown,
+  _req: Request,
+  res: Response,
+  _next: NextFunction
+) {
+  console.error(error);
+  res.status(500).json({ error: "Internal Server Error" });
+}
+

src/server/routes/consumer.routes.ts

@@ -0,0 +1,8 @@
+import { Router } from "express";
+import { createConsumer, listConsumersByProject } from "../controllers/consumer.controller.js";
+
+export const consumerRouter = Router();
+
+consumerRouter.get("/projects/:projectId", listConsumersByProject);
+consumerRouter.post("/", createConsumer);
+

src/server/routes/project.routes.ts

@@ -0,0 +1,8 @@
+import { Router } from "express";
+import { createProject, listProjects } from "../controllers/project.controller.js";
+
+export const projectRouter = Router();
+
+projectRouter.get("/", listProjects);
+projectRouter.post("/", createProject);
+

src/shared/types/power.types.ts

@@ -0,0 +1,26 @@
+export interface ProjectDto {
+  id: string;
+  name: string;
+}
+
+export interface DistributionBoardDto {
+  id: string;
+  projectId: string;
+  name: string;
+}
+
+export interface ConsumerDto {
+  id: string;
+  projectId: string;
+  distributionBoardId: string | null;
+  name: string;
+  category: string | null;
+  quantity: number;
+  installedPowerPerUnitKw: number;
+  demandFactor: number;
+  voltageV: number | null;
+  phaseCount: 1 | 3 | null;
+  powerFactor: number | null;
+  note: string | null;
+}
+

src/shared/validation/consumer.schemas.ts

@@ -0,0 +1,23 @@
+import { z } from "zod";
+
+export const createConsumerSchema = z.object({
+  projectId: z.string().min(1),
+  distributionBoardId: z.string().min(1).optional(),
+  name: z.string().min(1),
+  category: z.string().optional(),
+  quantity: z.number().min(0),
+  installedPowerPerUnitKw: z.number().min(0),
+  demandFactor: z.number().min(0).max(1),
+  voltageV: z.number().positive().optional(),
+  phaseCount: z.union([z.literal(1), z.literal(3)]).optional(),
+  powerFactor: z.number().min(0).max(1).optional(),
+  note: z.string().optional(),
+});
+
+export const createProjectSchema = z.object({
+  name: z.string().min(1),
+});
+
+export type CreateConsumerInput = z.infer<typeof createConsumerSchema>;
+export type CreateProjectInput = z.infer<typeof createProjectSchema>;
+