Stufe 0: Grundgerüst mit Rechenkern, Datenbank, Oberfläche und Docker-Betrieb

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AmyPfuNc4sCRfaF3oURXZz
This commit is contained in:
Claude
2026-10-17 16:37:54 +00:00
commit 92d26baa4b
45 changed files with 6143 additions and 0 deletions

168
src/server/app.ts Normal file
View File

@@ -0,0 +1,168 @@
import Fastify, { type FastifyInstance, type FastifyRequest } from "fastify";
import fastifyStatic from "@fastify/static";
import { fileURLToPath } from "node:url";
import path from "node:path";
import { existsSync } from "node:fs";
import { z, ZodError } from "zod";
import { type Pool, transaktion } from "./db.js";
import { TABELLEN } from "./tabellen.js";
import { EinstellungenSchema, type Einstellungen } from "./einstellungen.js";
import { liquiditaet, type Daten } from "../domain/liquiditaet.js";
import { VERSION } from "./version.js";
export interface Optionen {
pool: Pool;
webOrdner?: string;
logger?: boolean;
}
/** Benutzer kommt vom Proxy (Anmeldung); ohne Proxy, z. B. lokal, gilt "lokal". */
function benutzer(req: FastifyRequest): string {
const h = req.headers["x-benutzer"];
return (Array.isArray(h) ? h[0] : h)?.trim() || "lokal";
}
const IdParam = z.object({ id: z.uuid() });
export async function baueApp(o: Optionen): Promise<FastifyInstance> {
const app = Fastify({ logger: o.logger ?? false, bodyLimit: 50 * 1024 * 1024 });
const { pool } = o;
app.setErrorHandler((err, _req, reply) => {
if (err instanceof ZodError) {
return reply.status(400).send({ fehler: "Eingabe ungültig", details: err.issues.map((i) => `${i.path.join(".")}: ${i.message}`) });
}
const pgCode = (err as { code?: string }).code;
if (pgCode === "23503") return reply.status(409).send({ fehler: "Verknüpfter Datensatz fehlt oder wird noch verwendet" });
if (pgCode === "23505") return reply.status(409).send({ fehler: "Eintrag gibt es schon" });
if (pgCode === "23514" || pgCode === "22P02" || pgCode === "22007" || pgCode === "22008") {
return reply.status(400).send({ fehler: "Eingabe ungültig" });
}
const status = (err as { statusCode?: number }).statusCode;
if (status && status < 500) return reply.status(status).send({ fehler: (err as Error).message });
app.log.error(err);
return reply.status(500).send({ fehler: "Interner Fehler" });
});
app.get("/api/status", async () => {
await pool.query("select 1");
return { ok: true, version: VERSION };
});
for (const t of TABELLEN) {
const felder = Object.keys(t.schema.shape);
const teil = t.schema.partial();
app.get(`/api/${t.pfad}`, async () => (await pool.query(`select * from ${t.name} order by ${t.sortierung}`)).rows);
app.get(`/api/${t.pfad}/:id`, async (req, reply) => {
const { id } = IdParam.parse(req.params);
const r = await pool.query(`select * from ${t.name} where id = $1`, [id]);
return r.rows[0] ?? reply.status(404).send({ fehler: "Nicht gefunden" });
});
app.post(`/api/${t.pfad}`, async (req, reply) => {
const daten = t.schema.parse(req.body) as Record<string, unknown>;
const spalten = felder.filter((f) => daten[f] !== undefined);
const row = await transaktion(pool, benutzer(req), async (c) =>
(await c.query(
spalten.length
? `insert into ${t.name} (${spalten.join(", ")}) values (${spalten.map((_, i) => `$${i + 1}`).join(", ")}) returning *`
: `insert into ${t.name} default values returning *`,
spalten.map((s) => daten[s]),
)).rows[0],
);
return reply.status(201).send(row);
});
app.patch(`/api/${t.pfad}/:id`, async (req, reply) => {
const { id } = IdParam.parse(req.params);
const daten = teil.parse(req.body) as Record<string, unknown>;
const spalten = felder.filter((f) => daten[f] !== undefined);
if (spalten.length === 0) return reply.status(400).send({ fehler: "Keine Änderung angegeben" });
const row = await transaktion(pool, benutzer(req), async (c) =>
(await c.query(
`update ${t.name} set ${spalten.map((s, i) => `${s} = $${i + 2}`).join(", ")} where id = $1 returning *`,
[id, ...spalten.map((s) => daten[s])],
)).rows[0],
);
return row ?? reply.status(404).send({ fehler: "Nicht gefunden" });
});
app.delete(`/api/${t.pfad}/:id`, async (req, reply) => {
const { id } = IdParam.parse(req.params);
const n = await transaktion(pool, benutzer(req), async (c) => (await c.query(`delete from ${t.name} where id = $1`, [id])).rowCount);
return n ? reply.status(204).send() : reply.status(404).send({ fehler: "Nicht gefunden" });
});
}
async function ladeEinstellungen(): Promise<Einstellungen> {
const r = await pool.query<{ daten: unknown }>("select daten from einstellungen limit 1");
return EinstellungenSchema.parse(r.rows[0]?.daten ?? {});
}
app.get("/api/einstellungen", ladeEinstellungen);
app.put("/api/einstellungen", async (req) => {
const neu = EinstellungenSchema.parse(req.body);
await transaktion(pool, benutzer(req), (c) => c.query("update einstellungen set daten = $1", [neu]));
return neu;
});
const LiquiAnfrage = z.object({
ansicht: z.enum(["woche", "monat"]).default("woche"),
start: z.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional(),
anzahl: z.coerce.number().int().min(1).max(104).default(12),
});
app.get("/api/liquiditaet", async (req) => {
const q = LiquiAnfrage.parse(req.query);
const e = await ladeEinstellungen();
const [zahlungen, kosten, laufend] = await Promise.all([
pool.query(`select z.*, p.nummer from zahlung z join projekt p on p.id = z.projekt_id`),
pool.query(`select k.*, p.nummer from kosten k join projekt p on p.id = k.projekt_id`),
pool.query(`select * from laufende_kosten`),
]);
const daten: Daten = {
einnahmen: zahlungen.rows.map((z) => ({
projekt: z.nummer, bezeichnung: z.bezeichnung, netto: z.netto,
termin: z.rechnungsdatum ?? z.termin, bezahltAm: z.bezahlt_am ?? undefined,
})),
ausgaben: kosten.rows.map((k) => ({
projekt: k.nummer, bezeichnung: k.bezeichnung, art: k.art, netto: k.netto, termin: k.termin, mitVorsteuer: k.mit_vorsteuer,
})),
laufend: laufend.rows.map((l) => ({
bezeichnung: l.bezeichnung, kategorie: l.kategorie, betrag: l.betrag, rhythmus: l.rhythmus, start: l.start, ende: l.ende ?? undefined,
})),
};
const start = q.start ?? new Date().toISOString().slice(0, 10);
return liquiditaet(daten, { ansicht: q.ansicht, start, anzahl: q.anzahl, startsaldo: e.startsaldo, ziele: e.zahlungsziele, ust: e.ust });
});
// D1: kompletter Stand als JSON-Datei
app.get("/api/export", async (_req, reply) => {
const daten: Record<string, unknown[]> = {};
for (const t of TABELLEN) daten[t.pfad] = (await pool.query(`select * from ${t.name} order by ${t.sortierung}`)).rows;
const stand = new Date().toISOString();
reply.header("content-disposition", `attachment; filename="betrieb-${stand.slice(0, 10)}.json"`);
return { programm: "betrieb", version: VERSION, stand, einstellungen: await ladeEinstellungen(), daten };
});
app.get("/api/protokoll", async (req) => {
const q = z.object({ datensatz: z.uuid().optional(), limit: z.coerce.number().int().min(1).max(500).default(100) }).parse(req.query);
const r = q.datensatz
? await pool.query("select * from protokoll where datensatz = $1 order by id desc limit $2", [q.datensatz, q.limit])
: await pool.query("select * from protokoll order by id desc limit $1", [q.limit]);
return r.rows;
});
const web = o.webOrdner ?? path.join(path.dirname(fileURLToPath(import.meta.url)), "..", "web");
if (existsSync(web)) {
await app.register(fastifyStatic, { root: web, prefix: "/" });
app.setNotFoundHandler((req, reply) =>
req.url.startsWith("/api/") ? reply.status(404).send({ fehler: "Nicht gefunden" }) : reply.sendFile("index.html"),
);
}
return app;
}

34
src/server/db.ts Normal file
View File

@@ -0,0 +1,34 @@
import pg from "pg";
// date als 'JJJJ-MM-TT' lassen, bigint (Cent) und numeric als Zahl liefern
pg.types.setTypeParser(1082, (v) => v);
pg.types.setTypeParser(20, (v) => {
const n = Number(v);
if (!Number.isSafeInteger(n)) throw new Error(`Betrag zu groß: ${v}`);
return n;
});
pg.types.setTypeParser(1700, (v) => Number(v));
export type Pool = pg.Pool;
export type Client = pg.PoolClient;
export function erstellePool(url: string): Pool {
return new pg.Pool({ connectionString: url, max: 10 });
}
/** Führt fn in einer Transaktion aus; der Benutzer landet im Änderungsprotokoll. */
export async function transaktion<T>(pool: Pool, benutzer: string, fn: (c: Client) => Promise<T>): Promise<T> {
const c = await pool.connect();
try {
await c.query("begin");
await c.query("select set_config('betrieb.benutzer', $1, true)", [benutzer]);
const ergebnis = await fn(c);
await c.query("commit");
return ergebnis;
} catch (e) {
await c.query("rollback");
throw e;
} finally {
c.release();
}
}

View File

@@ -0,0 +1,29 @@
import { z } from "zod";
export const EinstellungenSchema = z.object({
arbeitstage: z.array(z.number().int().min(1).max(7)).default([1, 2, 3, 4]),
stundenProTag: z.number().positive().default(8),
produktivitaet: z.number().positive().max(1).default(1),
rundung: z.enum(["auf", "kaufmaennisch", "halbe"]).default("auf"),
zahlungsziele: z
.object({
kundenTage: z.number().int().min(0).default(14),
materialTage: z.number().int().min(0).default(30),
fremdTage: z.number().int().min(0).default(14),
sonstigeTage: z.number().int().min(0).default(0),
})
.prefault({}),
ust: z
.object({
satz: z.number().min(0).default(19),
voranmeldung: z.enum(["monatlich", "vierteljaehrlich"]).default("monatlich"),
dauerfristverlaengerung: z.boolean().default(false),
versteuerung: z.enum(["soll", "ist"]).default("soll"),
})
.prefault({}),
startsaldo: z.number().int().default(0),
startsaldoDatum: z.string().regex(/^\d{4}-\d{2}-\d{2}$/).nullable().default(null),
mindestreserve: z.number().int().default(0),
});
export type Einstellungen = z.infer<typeof EinstellungenSchema>;

23
src/server/index.ts Normal file
View File

@@ -0,0 +1,23 @@
import { erstellePool } from "./db.js";
import { migriere } from "./migrate.js";
import { baueApp } from "./app.js";
const url = process.env.DATABASE_URL;
if (!url) {
console.error("DATABASE_URL fehlt");
process.exit(1);
}
const pool = erstellePool(url);
await migriere(pool, (t) => console.log(t));
const app = await baueApp({ pool, logger: true });
const port = Number(process.env.PORT ?? 3000);
await app.listen({ host: "0.0.0.0", port });
for (const signal of ["SIGINT", "SIGTERM"] as const) {
process.on(signal, async () => {
await app.close();
await pool.end();
process.exit(0);
});
}

40
src/server/migrate.ts Normal file
View File

@@ -0,0 +1,40 @@
import { readdir, readFile } from "node:fs/promises";
import { fileURLToPath } from "node:url";
import path from "node:path";
import type { Pool } from "./db.js";
const ORDNER = path.join(path.dirname(fileURLToPath(import.meta.url)), "migrations");
/**
* Spielt alle noch fehlenden Migrationen in Namensreihenfolge ein, jede in eigener Transaktion.
* Eine Sperre verhindert, dass zwei Container gleichzeitig migrieren.
*/
export async function migriere(pool: Pool, log: (text: string) => void = () => {}): Promise<string[]> {
const c = await pool.connect();
const neu: string[] = [];
try {
await c.query("select pg_advisory_lock(4711)");
await c.query("create table if not exists schema_version (name text primary key, eingespielt_am timestamptz not null default now())");
const vorhanden = new Set((await c.query<{ name: string }>("select name from schema_version")).rows.map((r) => r.name));
const dateien = (await readdir(ORDNER)).filter((d) => d.endsWith(".sql")).sort();
for (const datei of dateien) {
if (vorhanden.has(datei)) continue;
const sql = await readFile(path.join(ORDNER, datei), "utf8");
await c.query("begin");
try {
await c.query(sql);
await c.query("insert into schema_version (name) values ($1)", [datei]);
await c.query("commit");
} catch (e) {
await c.query("rollback");
throw new Error(`Migration ${datei} fehlgeschlagen: ${(e as Error).message}`);
}
log(`Migration ${datei} eingespielt`);
neu.push(datei);
}
} finally {
await c.query("select pg_advisory_unlock(4711)").catch(() => {});
c.release();
}
return neu;
}

View File

@@ -0,0 +1,203 @@
-- Stufe 0: Grundlage. Objekte aus V70 mit fester ID; Verknüpfungen nur über IDs.
-- Beträge in Cent (bigint), Datumsangaben als date.
-- Jede Tabelle speichert, wer wann geändert hat; jede Änderung landet im Protokoll.
create table protokoll (
id bigserial primary key,
zeitpunkt timestamptz not null default now(),
benutzer text not null,
tabelle text not null,
datensatz uuid not null,
aktion text not null check (aktion in ('anlegen', 'aendern', 'loeschen')),
vorher jsonb,
nachher jsonb
);
create index protokoll_datensatz on protokoll (datensatz);
create function stempel_und_protokoll() returns trigger language plpgsql as $$
declare
wer text := coalesce(nullif(current_setting('betrieb.benutzer', true), ''), 'system');
begin
if tg_op = 'DELETE' then
insert into protokoll (benutzer, tabelle, datensatz, aktion, vorher)
values (wer, tg_table_name, old.id, 'loeschen', to_jsonb(old));
return old;
end if;
new.geaendert_am := now();
new.geaendert_von := wer;
if tg_op = 'INSERT' then
new.angelegt_am := now();
insert into protokoll (benutzer, tabelle, datensatz, aktion, nachher)
values (wer, tg_table_name, new.id, 'anlegen', to_jsonb(new));
else
new.angelegt_am := old.angelegt_am;
insert into protokoll (benutzer, tabelle, datensatz, aktion, vorher, nachher)
values (wer, tg_table_name, new.id, 'aendern', to_jsonb(old), to_jsonb(new));
end if;
return new;
end $$;
create table kontakt (
id uuid primary key default gen_random_uuid(),
name text not null,
firma text,
rolle text not null default 'sonstige'
check (rolle in ('bauherr', 'subunternehmer', 'lieferant', 'planer', 'mitarbeiter', 'sonstige')),
telefon text,
email text,
gewerk text,
notiz text,
angelegt_am timestamptz not null default now(),
geaendert_am timestamptz not null default now(),
geaendert_von text not null default 'system'
);
create table projekt (
id uuid primary key default gen_random_uuid(),
nummer text not null unique,
bezeichnung text not null,
bauherr_id uuid references kontakt (id) on delete set null,
status text not null default 'auftrag'
check (status in ('anfrage', 'angebot', 'auftrag', 'ausfuehrung', 'abgerechnet', 'gewaehrleistung', 'abgeschlossen')),
-- Projektpauschalen aus V70 (Einzelposten werden davon abgezogen)
umsatz_netto bigint not null default 0,
material_kosten bigint not null default 0,
fremd_kosten bigint not null default 0,
sonstige_kosten bigint not null default 0,
vertragsart text check (vertragsart in ('vob', 'bgb')),
abnahme_am date,
farbe text,
nextcloud_link text,
reihenfolge integer not null default 0,
angelegt_am timestamptz not null default now(),
geaendert_am timestamptz not null default now(),
geaendert_von text not null default 'system'
);
-- Abschnitte und Meilensteine sind gleichrangig unter dem Projekt
create table abschnitt (
id uuid primary key default gen_random_uuid(),
projekt_id uuid not null references projekt (id) on delete cascade,
name text not null,
ist_meilenstein boolean not null default false,
reihenfolge integer not null default 0,
erledigt boolean not null default false,
-- nur für Meilensteine ohne Vorgänge
termin date,
angelegt_am timestamptz not null default now(),
geaendert_am timestamptz not null default now(),
geaendert_von text not null default 'system'
);
create index abschnitt_projekt on abschnitt (projekt_id);
create table vorgang (
id uuid primary key default gen_random_uuid(),
abschnitt_id uuid not null references abschnitt (id) on delete cascade,
name text not null,
start date not null,
-- Dauer in Arbeitstagen; 0 = Meilenstein
dauer numeric(6, 1) not null default 1 check (dauer >= 0),
stunden numeric(8, 2),
kontakt_id uuid references kontakt (id) on delete set null,
reihenfolge integer not null default 0,
fortschritt integer not null default 0 check (fortschritt between 0 and 100),
angelegt_am timestamptz not null default now(),
geaendert_am timestamptz not null default now(),
geaendert_von text not null default 'system'
);
create index vorgang_abschnitt on vorgang (abschnitt_id);
-- Mehrere Vorgänger je Vorgang sind im Modell vorgesehen (T5)
create table vorgang_vorgaenger (
id uuid primary key default gen_random_uuid(),
vorgang_id uuid not null references vorgang (id) on delete cascade,
vorgaenger_id uuid not null references vorgang (id) on delete cascade,
art text not null default 'EA' check (art in ('EA', 'AA', 'EE', 'AE')),
verzoegerung integer not null default 0,
angelegt_am timestamptz not null default now(),
geaendert_am timestamptz not null default now(),
geaendert_von text not null default 'system',
unique (vorgang_id, vorgaenger_id),
check (vorgang_id <> vorgaenger_id)
);
create table zahlung (
id uuid primary key default gen_random_uuid(),
projekt_id uuid not null references projekt (id) on delete cascade,
vorgang_id uuid references vorgang (id) on delete set null,
art text not null default 'abschlag' check (art in ('anzahlung', 'abschlag', 'nachtrag', 'schluss', 'einbehalt')),
bezeichnung text not null,
netto bigint not null,
termin date not null,
status text not null default 'geplant' check (status in ('geplant', 'gestellt', 'bezahlt')),
rechnungsdatum date,
bezahlt_am date,
reihenfolge integer not null default 0,
angelegt_am timestamptz not null default now(),
geaendert_am timestamptz not null default now(),
geaendert_von text not null default 'system'
);
create index zahlung_projekt on zahlung (projekt_id);
create table kosten (
id uuid primary key default gen_random_uuid(),
projekt_id uuid not null references projekt (id) on delete cascade,
art text not null check (art in ('material', 'fremd', 'sonstiges')),
bezeichnung text not null,
netto bigint not null,
termin date not null,
kontakt_id uuid references kontakt (id) on delete set null,
mit_vorsteuer boolean not null default true,
status text not null default 'geplant' check (status in ('geplant', 'bestellt', 'bezahlt')),
angelegt_am timestamptz not null default now(),
geaendert_am timestamptz not null default now(),
geaendert_von text not null default 'system'
);
create index kosten_projekt on kosten (projekt_id);
create table laufende_kosten (
id uuid primary key default gen_random_uuid(),
bezeichnung text not null,
kategorie text not null default 'Sonstiges',
betrag bigint not null,
rhythmus text not null default 'monatlich' check (rhythmus in ('einmalig', 'monatlich', 'vierteljaehrlich', 'jaehrlich')),
start date not null,
ende date,
angelegt_am timestamptz not null default now(),
geaendert_am timestamptz not null default now(),
geaendert_von text not null default 'system'
);
create table aufgabe (
id uuid primary key default gen_random_uuid(),
text text not null,
faellig_am date,
langfristig boolean not null default false,
projekt_id uuid references projekt (id) on delete set null,
kontakt_id uuid references kontakt (id) on delete set null,
erledigt_am timestamptz,
angelegt_am timestamptz not null default now(),
geaendert_am timestamptz not null default now(),
geaendert_von text not null default 'system'
);
-- Genau eine Zeile mit allen Einstellungen
create table einstellungen (
id uuid primary key default gen_random_uuid(),
einzeln boolean not null default true unique check (einzeln),
daten jsonb not null default '{}',
angelegt_am timestamptz not null default now(),
geaendert_am timestamptz not null default now(),
geaendert_von text not null default 'system'
);
insert into einstellungen (daten) values ('{}');
do $$
declare t text;
begin
foreach t in array array['kontakt', 'projekt', 'abschnitt', 'vorgang', 'vorgang_vorgaenger', 'zahlung',
'kosten', 'laufende_kosten', 'aufgabe', 'einstellungen'] loop
execute format('create trigger %I_protokoll before insert or update or delete on %I
for each row execute function stempel_und_protokoll()', t, t);
end loop;
end $$;

149
src/server/tabellen.ts Normal file
View File

@@ -0,0 +1,149 @@
// Eingabeprüfung für die Tabellen aus Stufe 0. Feldnamen = Spaltennamen.
import { z } from "zod";
const datum = z.string().regex(/^\d{4}-\d{2}-\d{2}$/, "Datum im Format JJJJ-MM-TT");
const cent = z.number().int("Betrag in ganzen Cent");
const id = z.uuid();
const text = z.string().trim().min(1, "darf nicht leer sein");
const optText = z.string().trim().nullable().optional();
export interface Tabelle {
name: string;
pfad: string;
schema: z.ZodObject;
sortierung: string;
}
export const TABELLEN: Tabelle[] = [
{
name: "kontakt",
pfad: "kontakte",
sortierung: "name",
schema: z.object({
name: text,
firma: optText,
rolle: z.enum(["bauherr", "subunternehmer", "lieferant", "planer", "mitarbeiter", "sonstige"]).optional(),
telefon: optText,
email: optText,
gewerk: optText,
notiz: optText,
}),
},
{
name: "projekt",
pfad: "projekte",
sortierung: "reihenfolge, nummer",
schema: z.object({
nummer: text,
bezeichnung: text,
bauherr_id: id.nullable().optional(),
status: z.enum(["anfrage", "angebot", "auftrag", "ausfuehrung", "abgerechnet", "gewaehrleistung", "abgeschlossen"]).optional(),
umsatz_netto: cent.optional(),
material_kosten: cent.optional(),
fremd_kosten: cent.optional(),
sonstige_kosten: cent.optional(),
vertragsart: z.enum(["vob", "bgb"]).nullable().optional(),
abnahme_am: datum.nullable().optional(),
farbe: optText,
nextcloud_link: optText,
reihenfolge: z.number().int().optional(),
}),
},
{
name: "abschnitt",
pfad: "abschnitte",
sortierung: "projekt_id, reihenfolge",
schema: z.object({
projekt_id: id,
name: text,
ist_meilenstein: z.boolean().optional(),
reihenfolge: z.number().int().optional(),
erledigt: z.boolean().optional(),
termin: datum.nullable().optional(),
}),
},
{
name: "vorgang",
pfad: "vorgaenge",
sortierung: "abschnitt_id, reihenfolge, start",
schema: z.object({
abschnitt_id: id,
name: text,
start: datum,
dauer: z.number().min(0).optional(),
stunden: z.number().min(0).nullable().optional(),
kontakt_id: id.nullable().optional(),
reihenfolge: z.number().int().optional(),
fortschritt: z.number().int().min(0).max(100).optional(),
}),
},
{
name: "vorgang_vorgaenger",
pfad: "verknuepfungen",
sortierung: "vorgang_id",
schema: z.object({
vorgang_id: id,
vorgaenger_id: id,
art: z.enum(["EA", "AA", "EE", "AE"]).optional(),
verzoegerung: z.number().int().optional(),
}),
},
{
name: "zahlung",
pfad: "zahlungen",
sortierung: "projekt_id, reihenfolge, termin",
schema: z.object({
projekt_id: id,
vorgang_id: id.nullable().optional(),
art: z.enum(["anzahlung", "abschlag", "nachtrag", "schluss", "einbehalt"]).optional(),
bezeichnung: text,
netto: cent,
termin: datum,
status: z.enum(["geplant", "gestellt", "bezahlt"]).optional(),
rechnungsdatum: datum.nullable().optional(),
bezahlt_am: datum.nullable().optional(),
reihenfolge: z.number().int().optional(),
}),
},
{
name: "kosten",
pfad: "kosten",
sortierung: "projekt_id, termin",
schema: z.object({
projekt_id: id,
art: z.enum(["material", "fremd", "sonstiges"]),
bezeichnung: text,
netto: cent,
termin: datum,
kontakt_id: id.nullable().optional(),
mit_vorsteuer: z.boolean().optional(),
status: z.enum(["geplant", "bestellt", "bezahlt"]).optional(),
}),
},
{
name: "laufende_kosten",
pfad: "laufende-kosten",
sortierung: "kategorie, bezeichnung",
schema: z.object({
bezeichnung: text,
kategorie: text.optional(),
betrag: cent,
rhythmus: z.enum(["einmalig", "monatlich", "vierteljaehrlich", "jaehrlich"]).optional(),
start: datum,
ende: datum.nullable().optional(),
}),
},
{
name: "aufgabe",
pfad: "aufgaben",
sortierung: "erledigt_am nulls first, faellig_am nulls last, angelegt_am",
schema: z.object({
text: text,
faellig_am: datum.nullable().optional(),
langfristig: z.boolean().optional(),
projekt_id: id.nullable().optional(),
kontakt_id: id.nullable().optional(),
erledigt_am: z.iso.datetime({ offset: true }).nullable().optional(),
}),
},
];

2
src/server/version.ts Normal file
View File

@@ -0,0 +1,2 @@
// Wird beim Release aus dem Git-Tag gesetzt (Umgebungsvariable APP_VERSION im Image).
export const VERSION = process.env.APP_VERSION ?? "entwicklung";