Baustein 1: Grundgeruest, Datenbank, Anmeldung, zwei Rollen
Legt das Fundament der Lern-Bar an: - Next.js 15 (App Router), React 19, TypeScript, ESLint, Vitest - SQLite ueber Drizzle hinter einer Repository-Schicht - Eigener Migrationslauf mit Pruefsummen, beim Start angewendet - Argon2id, serverseitige Sitzungen, HttpOnly-Cookie, SameSite=Lax - Rollen Ausbilder und Azubi, Rechteregeln als reine Funktionen - Verwaltung: Azubikonto und Ausbildung anlegen, Passwort, Sperren - Gestaltung Petrol/Bernstein, helle und dunkle Darstellung - Dockerfile, docker-compose, Lebenszeichen, update.sh mit Rueckfall - Sicherung und Wiederherstellung als Shell-Skripte - 29 Tests fuer Rechte, Zeitrechnung und Migrationslauf Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
This commit is contained in:
Florian Wilde
Claude Opus 5
@@ -0,0 +1,32 @@
|
||||
import { hash, verify } from '@node-rs/argon2';
|
||||
|
||||
/**
|
||||
* Argon2id mit bewusst konservativen Parametern – die Anmeldung passiert
|
||||
* selten, ein paar hundert Millisekunden fallen niemandem auf.
|
||||
*/
|
||||
const einstellungen = {
|
||||
algorithm: 2, // Algorithm.Argon2id – als Zahl, weil der Aufzählungstyp ein const enum ist
|
||||
memoryCost: 19456, // 19 MiB, Empfehlung des OWASP-Spickzettels
|
||||
timeCost: 2,
|
||||
parallelism: 1,
|
||||
} as const;
|
||||
|
||||
export async function passwortHashen(klartext: string): Promise<string> {
|
||||
return hash(klartext, einstellungen);
|
||||
}
|
||||
|
||||
export async function passwortPruefen(hashWert: string, klartext: string): Promise<boolean> {
|
||||
try {
|
||||
return await verify(hashWert, klartext);
|
||||
} catch {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
/** Mindestanforderung an ein Passwort – bewusst schlicht: Länge schlägt Zeichenklassen. */
|
||||
export function passwortMangel(klartext: string): string | null {
|
||||
if (klartext.length < 10) return 'Das Passwort muss mindestens 10 Zeichen lang sein.';
|
||||
if (klartext.length > 200) return 'Das Passwort darf höchstens 200 Zeichen lang sein.';
|
||||
if (/^\s|\s$/.test(klartext)) return 'Das Passwort darf nicht mit einem Leerzeichen beginnen oder enden.';
|
||||
return null;
|
||||
}
|
||||
@@ -0,0 +1,56 @@
|
||||
import 'server-only';
|
||||
import { redirect } from 'next/navigation';
|
||||
import { eq } from 'drizzle-orm';
|
||||
import { datenbank, schema } from '../db';
|
||||
import { angemeldeterBenutzer } from './sitzung';
|
||||
import { darfAzubiDatenSehen, darfBewerten, istAusbilder, type Betrachter } from './regeln';
|
||||
import type { Benutzer } from '../db/schema';
|
||||
|
||||
/** Angemeldeter Benutzer oder Weiterleitung zur Anmeldung. */
|
||||
export async function erfordereBenutzer(): Promise<Benutzer> {
|
||||
const benutzer = await angemeldeterBenutzer();
|
||||
if (!benutzer) redirect('/anmelden');
|
||||
return benutzer;
|
||||
}
|
||||
|
||||
export async function erfordereAusbilder(): Promise<Benutzer> {
|
||||
const benutzer = await erfordereBenutzer();
|
||||
if (!istAusbilder(benutzer)) redirect('/');
|
||||
return benutzer;
|
||||
}
|
||||
|
||||
/** Das Ausbildungsverhältnis eines Azubis (höchstens eines). */
|
||||
export function ausbildungVonAzubi(azubiId: string) {
|
||||
return datenbank().select().from(schema.ausbildung).where(eq(schema.ausbildung.azubiId, azubiId)).get() ?? null;
|
||||
}
|
||||
|
||||
/** Die Azubis, die dieser Ausbilder betreut. */
|
||||
export function azubisVonAusbilder(ausbilderId: string) {
|
||||
return datenbank()
|
||||
.select({ benutzer: schema.benutzer, ausbildung: schema.ausbildung })
|
||||
.from(schema.ausbildung)
|
||||
.innerJoin(schema.benutzer, eq(schema.benutzer.id, schema.ausbildung.azubiId))
|
||||
.where(eq(schema.ausbildung.ausbilderId, ausbilderId))
|
||||
.all();
|
||||
}
|
||||
|
||||
/**
|
||||
* Prüft den Zugriff auf die Daten eines Azubis und bricht sonst ab.
|
||||
* Jede Seite und jede Serveraktion, die fremde Daten anfasst, ruft das auf.
|
||||
*/
|
||||
export function erfordereZugriffAufAzubi(betrachter: Betrachter, azubiId: string): void {
|
||||
const bezug = ausbildungVonAzubi(azubiId);
|
||||
if (!darfAzubiDatenSehen(betrachter, azubiId, bezug)) {
|
||||
throw new Error('Kein Zugriff auf diese Daten.');
|
||||
}
|
||||
}
|
||||
|
||||
export function erfordereBewertungsrecht(betrachter: Betrachter, azubiId: string): void {
|
||||
const bezug = ausbildungVonAzubi(azubiId);
|
||||
if (!darfBewerten(betrachter, azubiId, bezug)) {
|
||||
throw new Error('Keine Berechtigung zum Bewerten.');
|
||||
}
|
||||
}
|
||||
|
||||
export { darfAzubiDatenSehen, darfBewerten, istAusbilder };
|
||||
export type { Betrachter };
|
||||
@@ -0,0 +1,109 @@
|
||||
import { describe, expect, it } from 'vitest';
|
||||
import {
|
||||
darfAzubiDatenSehen,
|
||||
darfBewerten,
|
||||
darfKontrolleBearbeiten,
|
||||
darfMusterloesungSehen,
|
||||
istAusbilder,
|
||||
type Betrachter,
|
||||
} from './regeln';
|
||||
|
||||
const ausbilder: Betrachter = { id: 'aus-1', rolle: 'ausbilder', aktiv: 1 };
|
||||
const andererAusbilder: Betrachter = { id: 'aus-2', rolle: 'ausbilder', aktiv: 1 };
|
||||
const azubi: Betrachter = { id: 'azu-1', rolle: 'azubi', aktiv: 1 };
|
||||
const andererAzubi: Betrachter = { id: 'azu-2', rolle: 'azubi', aktiv: 1 };
|
||||
|
||||
const bezug = { azubiId: 'azu-1', ausbilderId: 'aus-1' };
|
||||
|
||||
describe('darfAzubiDatenSehen', () => {
|
||||
it('lässt den Azubi seine eigenen Daten sehen', () => {
|
||||
expect(darfAzubiDatenSehen(azubi, 'azu-1', bezug)).toBe(true);
|
||||
});
|
||||
|
||||
it('verwehrt dem Azubi die Daten eines anderen Azubis', () => {
|
||||
expect(darfAzubiDatenSehen(azubi, 'azu-2', { azubiId: 'azu-2', ausbilderId: 'aus-1' })).toBe(false);
|
||||
expect(darfAzubiDatenSehen(andererAzubi, 'azu-1', bezug)).toBe(false);
|
||||
});
|
||||
|
||||
it('lässt den zuständigen Ausbilder die Daten seines Azubis sehen', () => {
|
||||
expect(darfAzubiDatenSehen(ausbilder, 'azu-1', bezug)).toBe(true);
|
||||
});
|
||||
|
||||
it('verwehrt einem fremden Ausbilder die Daten', () => {
|
||||
expect(darfAzubiDatenSehen(andererAusbilder, 'azu-1', bezug)).toBe(false);
|
||||
});
|
||||
|
||||
it('verwehrt den Zugriff, wenn es gar kein Ausbildungsverhältnis gibt', () => {
|
||||
expect(darfAzubiDatenSehen(ausbilder, 'azu-1', null)).toBe(false);
|
||||
expect(darfAzubiDatenSehen(ausbilder, 'azu-1', undefined)).toBe(false);
|
||||
});
|
||||
|
||||
it('verwehrt den Zugriff bei gesperrtem Konto – auch auf die eigenen Daten', () => {
|
||||
expect(darfAzubiDatenSehen({ ...azubi, aktiv: 0 }, 'azu-1', bezug)).toBe(false);
|
||||
expect(darfAzubiDatenSehen({ ...ausbilder, aktiv: 0 }, 'azu-1', bezug)).toBe(false);
|
||||
});
|
||||
|
||||
it('lässt sich nicht durch einen Bezug auf einen anderen Azubi täuschen', () => {
|
||||
// Bezug gehört zum Ausbilder, aber zu einem anderen Azubi.
|
||||
expect(darfAzubiDatenSehen(ausbilder, 'azu-9', { azubiId: 'azu-1', ausbilderId: 'aus-1' })).toBe(false);
|
||||
});
|
||||
});
|
||||
|
||||
describe('darfBewerten', () => {
|
||||
it('erlaubt es nur dem zuständigen Ausbilder', () => {
|
||||
expect(darfBewerten(ausbilder, 'azu-1', bezug)).toBe(true);
|
||||
expect(darfBewerten(andererAusbilder, 'azu-1', bezug)).toBe(false);
|
||||
});
|
||||
|
||||
it('erlaubt es dem Azubi nie – auch nicht für sich selbst', () => {
|
||||
expect(darfBewerten(azubi, 'azu-1', bezug)).toBe(false);
|
||||
});
|
||||
});
|
||||
|
||||
describe('istAusbilder', () => {
|
||||
it('erkennt die Rolle und achtet auf das gesperrte Konto', () => {
|
||||
expect(istAusbilder(ausbilder)).toBe(true);
|
||||
expect(istAusbilder(azubi)).toBe(false);
|
||||
expect(istAusbilder({ ...ausbilder, aktiv: 0 })).toBe(false);
|
||||
});
|
||||
});
|
||||
|
||||
describe('darfMusterloesungSehen', () => {
|
||||
const nichtAbgegeben = { azubiId: 'azu-1', abgegebenAm: null };
|
||||
const abgegeben = { azubiId: 'azu-1', abgegebenAm: '2026-09-10T09:00:00.000Z' };
|
||||
|
||||
it('zeigt dem Azubi die Musterlösung erst nach dem Absenden', () => {
|
||||
expect(darfMusterloesungSehen(azubi, nichtAbgegeben, bezug)).toBe(false);
|
||||
expect(darfMusterloesungSehen(azubi, abgegeben, bezug)).toBe(true);
|
||||
});
|
||||
|
||||
it('zeigt sie dem zuständigen Ausbilder jederzeit', () => {
|
||||
expect(darfMusterloesungSehen(ausbilder, nichtAbgegeben, bezug)).toBe(true);
|
||||
});
|
||||
|
||||
it('zeigt sie niemandem Fremden', () => {
|
||||
expect(darfMusterloesungSehen(andererAusbilder, abgegeben, bezug)).toBe(false);
|
||||
expect(darfMusterloesungSehen(andererAzubi, abgegeben, bezug)).toBe(false);
|
||||
});
|
||||
});
|
||||
|
||||
describe('darfKontrolleBearbeiten', () => {
|
||||
it('nur zwischen Freigabe und Abgabe', () => {
|
||||
const gesperrt = { azubiId: 'azu-1', freigegebenAm: null, abgegebenAm: null };
|
||||
const offen = { azubiId: 'azu-1', freigegebenAm: '2026-09-10T07:00:00.000Z', abgegebenAm: null };
|
||||
const fertig = {
|
||||
azubiId: 'azu-1',
|
||||
freigegebenAm: '2026-09-10T07:00:00.000Z',
|
||||
abgegebenAm: '2026-09-10T09:00:00.000Z',
|
||||
};
|
||||
|
||||
expect(darfKontrolleBearbeiten(azubi, gesperrt)).toBe(false);
|
||||
expect(darfKontrolleBearbeiten(azubi, offen)).toBe(true);
|
||||
expect(darfKontrolleBearbeiten(azubi, fertig)).toBe(false);
|
||||
});
|
||||
|
||||
it('gilt nicht für den Ausbilder – der korrigiert, er schreibt nicht mit', () => {
|
||||
const offen = { azubiId: 'azu-1', freigegebenAm: '2026-09-10T07:00:00.000Z', abgegebenAm: null };
|
||||
expect(darfKontrolleBearbeiten(ausbilder, offen)).toBe(false);
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,56 @@
|
||||
import type { Rolle } from '../db/schema';
|
||||
|
||||
/**
|
||||
* Reine Rechteregeln, ohne Datenbank und ohne Next.js – damit sie sich
|
||||
* vollständig testen lassen. Die Aufrufer holen die nötigen Datensätze und
|
||||
* fragen hier nach dem Urteil.
|
||||
*/
|
||||
|
||||
export type Betrachter = { id: string; rolle: Rolle; aktiv: number };
|
||||
export type Ausbildungsbezug = { azubiId: string; ausbilderId: string } | null | undefined;
|
||||
|
||||
/** Darf der Betrachter die Daten dieses Azubis sehen? */
|
||||
export function darfAzubiDatenSehen(betrachter: Betrachter, azubiId: string, bezug: Ausbildungsbezug): boolean {
|
||||
if (betrachter.aktiv !== 1) return false;
|
||||
if (betrachter.rolle === 'azubi') return betrachter.id === azubiId;
|
||||
if (betrachter.rolle === 'ausbilder') {
|
||||
if (!bezug) return false;
|
||||
return bezug.azubiId === azubiId && bezug.ausbilderId === betrachter.id;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/** Darf der Betrachter die Daten dieses Azubis bewerten, abnehmen, abzeichnen? */
|
||||
export function darfBewerten(betrachter: Betrachter, azubiId: string, bezug: Ausbildungsbezug): boolean {
|
||||
return betrachter.rolle === 'ausbilder' && darfAzubiDatenSehen(betrachter, azubiId, bezug);
|
||||
}
|
||||
|
||||
/** Nur der Ausbilder pflegt Konten und Wochenplanung. */
|
||||
export function istAusbilder(betrachter: Betrachter): boolean {
|
||||
return betrachter.aktiv === 1 && betrachter.rolle === 'ausbilder';
|
||||
}
|
||||
|
||||
/**
|
||||
* Musterlösungen sind der empfindlichste Teil: Der Azubi darf sie erst nach dem
|
||||
* Absenden sehen. Diese Regel wird serverseitig vor jeder Ausgabe befragt –
|
||||
* nicht erst in der Oberfläche.
|
||||
*/
|
||||
export function darfMusterloesungSehen(
|
||||
betrachter: Betrachter,
|
||||
kontrolle: { azubiId: string; abgegebenAm: string | null },
|
||||
bezug: Ausbildungsbezug,
|
||||
): boolean {
|
||||
if (!darfAzubiDatenSehen(betrachter, kontrolle.azubiId, bezug)) return false;
|
||||
if (betrachter.rolle === 'ausbilder') return true;
|
||||
return kontrolle.abgegebenAm !== null;
|
||||
}
|
||||
|
||||
/** Der Azubi darf eine Kontrolle nur bearbeiten, solange sie freigegeben und nicht abgegeben ist. */
|
||||
export function darfKontrolleBearbeiten(
|
||||
betrachter: Betrachter,
|
||||
kontrolle: { azubiId: string; freigegebenAm: string | null; abgegebenAm: string | null },
|
||||
): boolean {
|
||||
if (betrachter.rolle !== 'azubi') return false;
|
||||
if (betrachter.id !== kontrolle.azubiId) return false;
|
||||
return kontrolle.freigegebenAm !== null && kontrolle.abgegebenAm === null;
|
||||
}
|
||||
@@ -0,0 +1,75 @@
|
||||
import 'server-only';
|
||||
import crypto from 'node:crypto';
|
||||
import { cookies } from 'next/headers';
|
||||
import { eq, lt } from 'drizzle-orm';
|
||||
import { datenbank, schema } from '../db';
|
||||
import { inTagen, jetzt } from '../zeit';
|
||||
import type { Benutzer } from '../db/schema';
|
||||
|
||||
export const SITZUNGS_COOKIE = 'lernbar_sitzung';
|
||||
const GUELTIG_TAGE = 30;
|
||||
|
||||
/**
|
||||
* Sitzungen liegen serverseitig in der Datenbank. Im Cookie steht nur ein
|
||||
* Zufallswert; gespeichert wird dessen SHA-256-Abdruck, damit ein Blick in die
|
||||
* Datenbank keine gültigen Sitzungen verrät.
|
||||
*/
|
||||
function abdruck(wert: string): string {
|
||||
return crypto.createHash('sha256').update(wert).digest('hex');
|
||||
}
|
||||
|
||||
export async function sitzungAnlegen(benutzerId: string): Promise<void> {
|
||||
const geheimnis = crypto.randomBytes(32).toString('base64url');
|
||||
const db = datenbank();
|
||||
|
||||
db.insert(schema.sitzung)
|
||||
.values({
|
||||
id: abdruck(geheimnis),
|
||||
benutzerId,
|
||||
erstelltAm: jetzt(),
|
||||
laeuftAbAm: inTagen(GUELTIG_TAGE),
|
||||
})
|
||||
.run();
|
||||
|
||||
// Abgelaufene Sitzungen bei Gelegenheit aufräumen.
|
||||
db.delete(schema.sitzung).where(lt(schema.sitzung.laeuftAbAm, jetzt())).run();
|
||||
|
||||
const keksdose = await cookies();
|
||||
keksdose.set(SITZUNGS_COOKIE, geheimnis, {
|
||||
httpOnly: true,
|
||||
sameSite: 'lax',
|
||||
secure: process.env.NODE_ENV === 'production',
|
||||
path: '/',
|
||||
maxAge: GUELTIG_TAGE * 24 * 3600,
|
||||
});
|
||||
}
|
||||
|
||||
export async function sitzungBeenden(): Promise<void> {
|
||||
const keksdose = await cookies();
|
||||
const geheimnis = keksdose.get(SITZUNGS_COOKIE)?.value;
|
||||
if (geheimnis) {
|
||||
datenbank().delete(schema.sitzung).where(eq(schema.sitzung.id, abdruck(geheimnis))).run();
|
||||
}
|
||||
keksdose.delete(SITZUNGS_COOKIE);
|
||||
}
|
||||
|
||||
/** Der angemeldete Benutzer oder `null`. Führt keine Weiterleitung aus. */
|
||||
export async function angemeldeterBenutzer(): Promise<Benutzer | null> {
|
||||
const keksdose = await cookies();
|
||||
const geheimnis = keksdose.get(SITZUNGS_COOKIE)?.value;
|
||||
if (!geheimnis) return null;
|
||||
|
||||
const db = datenbank();
|
||||
const treffer = db
|
||||
.select({ benutzer: schema.benutzer, laeuftAbAm: schema.sitzung.laeuftAbAm })
|
||||
.from(schema.sitzung)
|
||||
.innerJoin(schema.benutzer, eq(schema.benutzer.id, schema.sitzung.benutzerId))
|
||||
.where(eq(schema.sitzung.id, abdruck(geheimnis)))
|
||||
.get();
|
||||
|
||||
if (!treffer) return null;
|
||||
if (treffer.laeuftAbAm <= jetzt()) return null;
|
||||
if (treffer.benutzer.aktiv !== 1) return null;
|
||||
|
||||
return treffer.benutzer;
|
||||
}
|
||||
@@ -0,0 +1,59 @@
|
||||
import fs from 'node:fs';
|
||||
import path from 'node:path';
|
||||
import Database from 'better-sqlite3';
|
||||
import { drizzle, type BetterSQLite3Database } from 'drizzle-orm/better-sqlite3';
|
||||
import * as schema from './schema';
|
||||
import { migriere } from './migrator';
|
||||
import { anhangWurzel, datenbankDatei, datenWurzel } from '../pfade';
|
||||
|
||||
/**
|
||||
* Eine einzige Verbindung pro Prozess. Der Verweis hängt am globalThis, damit
|
||||
* das Neuladen im Entwicklungsbetrieb keine zweite Verbindung öffnet.
|
||||
*
|
||||
* Der gesamte Datenzugriff der Anwendung läuft über die Module unter
|
||||
* `src/lib/repos`. Nur diese Datei kennt better-sqlite3 – ein Wechsel auf
|
||||
* PostgreSQL tauscht Treiber und Dialekt hier aus, nicht in den Aufrufern.
|
||||
*/
|
||||
|
||||
type Halter = { db?: BetterSQLite3Database<typeof schema>; roh?: Database.Database };
|
||||
const halter = globalThis as unknown as { __lernbar?: Halter };
|
||||
halter.__lernbar ??= {};
|
||||
|
||||
function oeffne(): { db: BetterSQLite3Database<typeof schema>; roh: Database.Database } {
|
||||
fs.mkdirSync(datenWurzel, { recursive: true });
|
||||
fs.mkdirSync(anhangWurzel, { recursive: true });
|
||||
fs.mkdirSync(path.dirname(datenbankDatei), { recursive: true });
|
||||
|
||||
const roh = new Database(datenbankDatei);
|
||||
roh.pragma('journal_mode = WAL');
|
||||
roh.pragma('foreign_keys = ON');
|
||||
roh.pragma('busy_timeout = 5000');
|
||||
|
||||
const ergebnis = migriere(roh);
|
||||
if (ergebnis.angewendet.length > 0) {
|
||||
console.log(`[lernbar] Migrationen angewendet: ${ergebnis.angewendet.join(', ')}`);
|
||||
}
|
||||
|
||||
return { db: drizzle(roh, { schema }), roh };
|
||||
}
|
||||
|
||||
function verbindung() {
|
||||
if (!halter.__lernbar!.db) {
|
||||
const { db, roh } = oeffne();
|
||||
halter.__lernbar!.db = db;
|
||||
halter.__lernbar!.roh = roh;
|
||||
}
|
||||
return halter.__lernbar!;
|
||||
}
|
||||
|
||||
/** Der Abfrage-Einstieg für alle Repository-Module. */
|
||||
export function datenbank(): BetterSQLite3Database<typeof schema> {
|
||||
return verbindung().db!;
|
||||
}
|
||||
|
||||
/** Rohzugriff – nur für Sicherung, Wiederherstellung und Tests. */
|
||||
export function rohVerbindung(): Database.Database {
|
||||
return verbindung().roh!;
|
||||
}
|
||||
|
||||
export { schema };
|
||||
@@ -0,0 +1,38 @@
|
||||
-- Baustein 1: Benutzer, Sitzungen, Ausbildungsverhältnis.
|
||||
|
||||
CREATE TABLE benutzer (
|
||||
id TEXT PRIMARY KEY,
|
||||
name TEXT NOT NULL,
|
||||
email TEXT NOT NULL,
|
||||
passwort_hash TEXT NOT NULL,
|
||||
rolle TEXT NOT NULL CHECK (rolle IN ('ausbilder', 'azubi')),
|
||||
aktiv INTEGER NOT NULL DEFAULT 1 CHECK (aktiv IN (0, 1)),
|
||||
erstellt_am TEXT NOT NULL,
|
||||
letzte_anmeldung_am TEXT
|
||||
);
|
||||
|
||||
CREATE UNIQUE INDEX benutzer_email_idx ON benutzer (email);
|
||||
|
||||
CREATE TABLE sitzung (
|
||||
id TEXT PRIMARY KEY,
|
||||
benutzer_id TEXT NOT NULL REFERENCES benutzer (id) ON DELETE CASCADE,
|
||||
erstellt_am TEXT NOT NULL,
|
||||
laeuft_ab_am TEXT NOT NULL
|
||||
);
|
||||
|
||||
CREATE INDEX sitzung_benutzer_idx ON sitzung (benutzer_id);
|
||||
CREATE INDEX sitzung_ablauf_idx ON sitzung (laeuft_ab_am);
|
||||
|
||||
CREATE TABLE ausbildung (
|
||||
id TEXT PRIMARY KEY,
|
||||
azubi_id TEXT NOT NULL REFERENCES benutzer (id) ON DELETE CASCADE,
|
||||
ausbilder_id TEXT NOT NULL REFERENCES benutzer (id) ON DELETE RESTRICT,
|
||||
beruf TEXT NOT NULL DEFAULT 'Fachinformatiker/-in für Systemintegration',
|
||||
beginn TEXT NOT NULL,
|
||||
ende TEXT,
|
||||
probezeit_bis TEXT,
|
||||
erstellt_am TEXT NOT NULL
|
||||
);
|
||||
|
||||
CREATE UNIQUE INDEX ausbildung_azubi_idx ON ausbildung (azubi_id);
|
||||
CREATE INDEX ausbildung_ausbilder_idx ON ausbildung (ausbilder_id);
|
||||
@@ -0,0 +1,107 @@
|
||||
import fs from 'node:fs';
|
||||
import os from 'node:os';
|
||||
import path from 'node:path';
|
||||
import Database from 'better-sqlite3';
|
||||
import { afterEach, describe, expect, it } from 'vitest';
|
||||
import { migriere, migrationsVerzeichnis } from './migrator';
|
||||
import * as schema from './schema';
|
||||
import { getTableConfig } from 'drizzle-orm/sqlite-core';
|
||||
|
||||
const aufraeumen: string[] = [];
|
||||
|
||||
function temporaeresVerzeichnis(): string {
|
||||
const verzeichnis = fs.mkdtempSync(path.join(os.tmpdir(), 'lernbar-test-'));
|
||||
aufraeumen.push(verzeichnis);
|
||||
return verzeichnis;
|
||||
}
|
||||
|
||||
afterEach(() => {
|
||||
while (aufraeumen.length > 0) {
|
||||
const verzeichnis = aufraeumen.pop()!;
|
||||
fs.rmSync(verzeichnis, { recursive: true, force: true });
|
||||
}
|
||||
});
|
||||
|
||||
describe('Migrationslauf', () => {
|
||||
it('wendet jede Datei genau einmal an', () => {
|
||||
const verzeichnis = temporaeresVerzeichnis();
|
||||
fs.writeFileSync(path.join(verzeichnis, '0001_erste.sql'), 'CREATE TABLE a (id TEXT PRIMARY KEY);');
|
||||
fs.writeFileSync(path.join(verzeichnis, '0002_zweite.sql'), 'CREATE TABLE b (id TEXT PRIMARY KEY);');
|
||||
|
||||
const db = new Database(':memory:');
|
||||
const erster = migriere(db, verzeichnis);
|
||||
expect(erster.angewendet).toEqual(['0001_erste', '0002_zweite']);
|
||||
|
||||
const zweiter = migriere(db, verzeichnis);
|
||||
expect(zweiter.angewendet).toEqual([]);
|
||||
expect(zweiter.uebersprungen).toBe(2);
|
||||
});
|
||||
|
||||
it('wendet in der Reihenfolge der Dateinamen an, nicht in Lesereihenfolge', () => {
|
||||
const verzeichnis = temporaeresVerzeichnis();
|
||||
// Absichtlich in verkehrter Reihenfolge geschrieben: 0002 setzt 0001 voraus.
|
||||
fs.writeFileSync(path.join(verzeichnis, '0002_zweite.sql'), 'ALTER TABLE a ADD COLUMN name TEXT;');
|
||||
fs.writeFileSync(path.join(verzeichnis, '0001_erste.sql'), 'CREATE TABLE a (id TEXT PRIMARY KEY);');
|
||||
|
||||
const db = new Database(':memory:');
|
||||
expect(() => migriere(db, verzeichnis)).not.toThrow();
|
||||
});
|
||||
|
||||
it('merkt, wenn eine bereits angewendete Datei nachträglich verändert wurde', () => {
|
||||
const verzeichnis = temporaeresVerzeichnis();
|
||||
const datei = path.join(verzeichnis, '0001_erste.sql');
|
||||
fs.writeFileSync(datei, 'CREATE TABLE a (id TEXT PRIMARY KEY);');
|
||||
|
||||
const db = new Database(':memory:');
|
||||
migriere(db, verzeichnis);
|
||||
|
||||
fs.writeFileSync(datei, 'CREATE TABLE a (id TEXT PRIMARY KEY, extra TEXT);');
|
||||
expect(() => migriere(db, verzeichnis)).toThrow(/verändert/);
|
||||
});
|
||||
|
||||
it('lässt bei einem Fehler mitten in der Datei nichts Halbes zurück', () => {
|
||||
const verzeichnis = temporaeresVerzeichnis();
|
||||
fs.writeFileSync(
|
||||
path.join(verzeichnis, '0001_kaputt.sql'),
|
||||
'CREATE TABLE a (id TEXT PRIMARY KEY);\nDAS IST KEIN SQL;',
|
||||
);
|
||||
|
||||
const db = new Database(':memory:');
|
||||
expect(() => migriere(db, verzeichnis)).toThrow();
|
||||
|
||||
const tabellen = db
|
||||
.prepare("SELECT name FROM sqlite_master WHERE type = 'table'")
|
||||
.all()
|
||||
.map((z) => (z as { name: string }).name);
|
||||
expect(tabellen).not.toContain('a');
|
||||
expect(
|
||||
db.prepare('SELECT COUNT(*) AS anzahl FROM schema_migration').get() as { anzahl: number },
|
||||
).toEqual({ anzahl: 0 });
|
||||
});
|
||||
|
||||
it('beschwert sich über ein fehlendes Verzeichnis statt still nichts zu tun', () => {
|
||||
const db = new Database(':memory:');
|
||||
expect(() => migriere(db, path.join(os.tmpdir(), 'gibt-es-nicht-lernbar'))).toThrow(/nicht gefunden/);
|
||||
});
|
||||
});
|
||||
|
||||
describe('Schema und Migrationen passen zusammen', () => {
|
||||
it('jede Tabelle und Spalte aus dem Drizzle-Schema existiert in der migrierten Datenbank', () => {
|
||||
const db = new Database(':memory:');
|
||||
migriere(db, migrationsVerzeichnis);
|
||||
|
||||
for (const tabelle of Object.values(schema.alleTabellen)) {
|
||||
const aufbau = getTableConfig(tabelle);
|
||||
const spalten = db
|
||||
.prepare(`PRAGMA table_info(${aufbau.name})`)
|
||||
.all()
|
||||
.map((z) => (z as { name: string }).name);
|
||||
|
||||
expect(spalten.length, `Tabelle ${aufbau.name} fehlt in den Migrationen`).toBeGreaterThan(0);
|
||||
|
||||
for (const spalte of aufbau.columns) {
|
||||
expect(spalten, `Spalte ${aufbau.name}.${spalte.name} fehlt in den Migrationen`).toContain(spalte.name);
|
||||
}
|
||||
}
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,74 @@
|
||||
import fs from 'node:fs';
|
||||
import path from 'node:path';
|
||||
import crypto from 'node:crypto';
|
||||
import type Database from 'better-sqlite3';
|
||||
|
||||
/**
|
||||
* Winziger, eigener Migrationslauf: alle .sql-Dateien im Verzeichnis werden
|
||||
* nach Dateinamen sortiert genau einmal angewendet und mit Prüfsumme vermerkt.
|
||||
* Bewusst kein Werkzeug von der Stange – der Bedarf ist eine Handvoll Dateien,
|
||||
* und so ist beim Start klar sichtbar, was passiert.
|
||||
*/
|
||||
|
||||
export const migrationsVerzeichnis =
|
||||
process.env.LERNBAR_MIGRATIONEN ?? path.join(process.cwd(), 'src', 'lib', 'db', 'migrationen');
|
||||
|
||||
export type Migrationsergebnis = { angewendet: string[]; uebersprungen: number };
|
||||
|
||||
export function migriere(db: Database.Database, verzeichnis = migrationsVerzeichnis): Migrationsergebnis {
|
||||
db.exec(`CREATE TABLE IF NOT EXISTS schema_migration (
|
||||
version TEXT PRIMARY KEY,
|
||||
angewendet_am TEXT NOT NULL,
|
||||
pruefsumme TEXT NOT NULL
|
||||
)`);
|
||||
|
||||
if (!fs.existsSync(verzeichnis)) {
|
||||
throw new Error(`Migrationsverzeichnis nicht gefunden: ${verzeichnis}`);
|
||||
}
|
||||
|
||||
const dateien = fs
|
||||
.readdirSync(verzeichnis)
|
||||
.filter((d) => d.endsWith('.sql'))
|
||||
.sort();
|
||||
|
||||
const bekannt = new Map<string, string>(
|
||||
db
|
||||
.prepare('SELECT version, pruefsumme FROM schema_migration')
|
||||
.all()
|
||||
.map((z) => [(z as { version: string }).version, (z as { pruefsumme: string }).pruefsumme]),
|
||||
);
|
||||
|
||||
const angewendet: string[] = [];
|
||||
let uebersprungen = 0;
|
||||
|
||||
for (const datei of dateien) {
|
||||
const version = datei.replace(/\.sql$/, '');
|
||||
const inhalt = fs.readFileSync(path.join(verzeichnis, datei), 'utf8');
|
||||
const pruefsumme = crypto.createHash('sha256').update(inhalt).digest('hex');
|
||||
const vorhanden = bekannt.get(version);
|
||||
|
||||
if (vorhanden) {
|
||||
if (vorhanden !== pruefsumme) {
|
||||
throw new Error(
|
||||
`Migration ${datei} wurde nach dem Anwenden verändert. ` +
|
||||
`Bereits angewendete Migrationen dürfen nicht bearbeitet werden – lege stattdessen eine neue Datei an.`,
|
||||
);
|
||||
}
|
||||
uebersprungen += 1;
|
||||
continue;
|
||||
}
|
||||
|
||||
const lauf = db.transaction(() => {
|
||||
db.exec(inhalt);
|
||||
db.prepare('INSERT INTO schema_migration (version, angewendet_am, pruefsumme) VALUES (?, ?, ?)').run(
|
||||
version,
|
||||
new Date().toISOString(),
|
||||
pruefsumme,
|
||||
);
|
||||
});
|
||||
lauf();
|
||||
angewendet.push(version);
|
||||
}
|
||||
|
||||
return { angewendet, uebersprungen };
|
||||
}
|
||||
@@ -0,0 +1,59 @@
|
||||
import { index, integer, sqliteTable, text, uniqueIndex } from 'drizzle-orm/sqlite-core';
|
||||
|
||||
/** Rollen – bewusst nur zwei. */
|
||||
export const rollen = ['ausbilder', 'azubi'] as const;
|
||||
export type Rolle = (typeof rollen)[number];
|
||||
|
||||
export const benutzer = sqliteTable(
|
||||
'benutzer',
|
||||
{
|
||||
id: text('id').primaryKey(),
|
||||
name: text('name').notNull(),
|
||||
email: text('email').notNull(),
|
||||
passwortHash: text('passwort_hash').notNull(),
|
||||
rolle: text('rolle', { enum: rollen }).notNull(),
|
||||
aktiv: integer('aktiv').notNull().default(1),
|
||||
erstelltAm: text('erstellt_am').notNull(),
|
||||
letzteAnmeldungAm: text('letzte_anmeldung_am'),
|
||||
},
|
||||
(t) => [uniqueIndex('benutzer_email_idx').on(t.email)],
|
||||
);
|
||||
|
||||
export const sitzung = sqliteTable(
|
||||
'sitzung',
|
||||
{
|
||||
id: text('id').primaryKey(),
|
||||
benutzerId: text('benutzer_id')
|
||||
.notNull()
|
||||
.references(() => benutzer.id, { onDelete: 'cascade' }),
|
||||
erstelltAm: text('erstellt_am').notNull(),
|
||||
laeuftAbAm: text('laeuft_ab_am').notNull(),
|
||||
},
|
||||
(t) => [index('sitzung_benutzer_idx').on(t.benutzerId), index('sitzung_ablauf_idx').on(t.laeuftAbAm)],
|
||||
);
|
||||
|
||||
export const ausbildung = sqliteTable(
|
||||
'ausbildung',
|
||||
{
|
||||
id: text('id').primaryKey(),
|
||||
azubiId: text('azubi_id')
|
||||
.notNull()
|
||||
.references(() => benutzer.id, { onDelete: 'cascade' }),
|
||||
ausbilderId: text('ausbilder_id')
|
||||
.notNull()
|
||||
.references(() => benutzer.id),
|
||||
beruf: text('beruf').notNull().default('Fachinformatiker/-in für Systemintegration'),
|
||||
beginn: text('beginn').notNull(),
|
||||
ende: text('ende'),
|
||||
probezeitBis: text('probezeit_bis'),
|
||||
erstelltAm: text('erstellt_am').notNull(),
|
||||
},
|
||||
(t) => [uniqueIndex('ausbildung_azubi_idx').on(t.azubiId), index('ausbildung_ausbilder_idx').on(t.ausbilderId)],
|
||||
);
|
||||
|
||||
export type Benutzer = typeof benutzer.$inferSelect;
|
||||
export type Sitzung = typeof sitzung.$inferSelect;
|
||||
export type Ausbildung = typeof ausbildung.$inferSelect;
|
||||
|
||||
/** Wird von der Schema-Abgleichprüfung im Test verwendet. */
|
||||
export const alleTabellen = { benutzer, sitzung, ausbildung };
|
||||
@@ -0,0 +1,14 @@
|
||||
import path from 'node:path';
|
||||
|
||||
/**
|
||||
* Alle veränderlichen Daten liegen unter einem Wurzelverzeichnis, das im
|
||||
* Container als Volume eingehängt wird. Inhalte dagegen kommen aus dem
|
||||
* Repository und sind unveränderlich.
|
||||
*/
|
||||
export const datenWurzel = path.resolve(process.env.LERNBAR_DATEN ?? path.join(process.cwd(), 'daten'));
|
||||
|
||||
export const datenbankDatei = process.env.LERNBAR_DB ?? path.join(datenWurzel, 'lernbar.sqlite');
|
||||
|
||||
export const anhangWurzel = path.join(datenWurzel, 'anhaenge');
|
||||
|
||||
export const inhaltWurzel = path.resolve(process.env.LERNBAR_INHALTE ?? path.join(process.cwd(), 'content'));
|
||||
@@ -0,0 +1,63 @@
|
||||
import crypto from 'node:crypto';
|
||||
import { eq } from 'drizzle-orm';
|
||||
import { datenbank, schema } from '../db';
|
||||
import { jetzt } from '../zeit';
|
||||
import type { Ausbildung, Benutzer } from '../db/schema';
|
||||
|
||||
export const STANDARD_BERUF = 'Fachinformatiker/-in für Systemintegration';
|
||||
|
||||
export function ausbildungNachAzubi(azubiId: string): Ausbildung | null {
|
||||
return datenbank().select().from(schema.ausbildung).where(eq(schema.ausbildung.azubiId, azubiId)).get() ?? null;
|
||||
}
|
||||
|
||||
export function ausbildungNachId(id: string): Ausbildung | null {
|
||||
return datenbank().select().from(schema.ausbildung).where(eq(schema.ausbildung.id, id)).get() ?? null;
|
||||
}
|
||||
|
||||
export type AusbildungMitAzubi = { ausbildung: Ausbildung; azubi: Benutzer };
|
||||
|
||||
export function ausbildungenVonAusbilder(ausbilderId: string): AusbildungMitAzubi[] {
|
||||
return datenbank()
|
||||
.select({ ausbildung: schema.ausbildung, azubi: schema.benutzer })
|
||||
.from(schema.ausbildung)
|
||||
.innerJoin(schema.benutzer, eq(schema.benutzer.id, schema.ausbildung.azubiId))
|
||||
.where(eq(schema.ausbildung.ausbilderId, ausbilderId))
|
||||
.all();
|
||||
}
|
||||
|
||||
export function alleAusbildungen(): AusbildungMitAzubi[] {
|
||||
return datenbank()
|
||||
.select({ ausbildung: schema.ausbildung, azubi: schema.benutzer })
|
||||
.from(schema.ausbildung)
|
||||
.innerJoin(schema.benutzer, eq(schema.benutzer.id, schema.ausbildung.azubiId))
|
||||
.all();
|
||||
}
|
||||
|
||||
export function ausbildungAnlegen(werte: {
|
||||
azubiId: string;
|
||||
ausbilderId: string;
|
||||
beruf?: string;
|
||||
beginn: string;
|
||||
ende?: string | null;
|
||||
probezeitBis?: string | null;
|
||||
}): Ausbildung {
|
||||
const datensatz: Ausbildung = {
|
||||
id: crypto.randomUUID(),
|
||||
azubiId: werte.azubiId,
|
||||
ausbilderId: werte.ausbilderId,
|
||||
beruf: werte.beruf?.trim() || STANDARD_BERUF,
|
||||
beginn: werte.beginn,
|
||||
ende: werte.ende ?? null,
|
||||
probezeitBis: werte.probezeitBis ?? null,
|
||||
erstelltAm: jetzt(),
|
||||
};
|
||||
datenbank().insert(schema.ausbildung).values(datensatz).run();
|
||||
return datensatz;
|
||||
}
|
||||
|
||||
export function ausbildungAendern(
|
||||
id: string,
|
||||
werte: Partial<Pick<Ausbildung, 'beruf' | 'beginn' | 'ende' | 'probezeitBis' | 'ausbilderId'>>,
|
||||
): void {
|
||||
datenbank().update(schema.ausbildung).set(werte).where(eq(schema.ausbildung.id, id)).run();
|
||||
}
|
||||
@@ -0,0 +1,70 @@
|
||||
import crypto from 'node:crypto';
|
||||
import { asc, eq } from 'drizzle-orm';
|
||||
import { datenbank, schema } from '../db';
|
||||
import { passwortHashen } from '../auth/passwort';
|
||||
import { jetzt } from '../zeit';
|
||||
import type { Benutzer, Rolle } from '../db/schema';
|
||||
|
||||
/** Sämtlicher Zugriff auf die Tabelle `benutzer` läuft über dieses Modul. */
|
||||
|
||||
export function alleBenutzer(): Benutzer[] {
|
||||
return datenbank().select().from(schema.benutzer).orderBy(asc(schema.benutzer.name)).all();
|
||||
}
|
||||
|
||||
export function benutzerNachId(id: string): Benutzer | null {
|
||||
return datenbank().select().from(schema.benutzer).where(eq(schema.benutzer.id, id)).get() ?? null;
|
||||
}
|
||||
|
||||
export function benutzerNachEmail(email: string): Benutzer | null {
|
||||
return (
|
||||
datenbank()
|
||||
.select()
|
||||
.from(schema.benutzer)
|
||||
.where(eq(schema.benutzer.email, email.trim().toLowerCase()))
|
||||
.get() ?? null
|
||||
);
|
||||
}
|
||||
|
||||
export function benutzerNachRolle(rolle: Rolle): Benutzer[] {
|
||||
return datenbank().select().from(schema.benutzer).where(eq(schema.benutzer.rolle, rolle)).all();
|
||||
}
|
||||
|
||||
export async function benutzerAnlegen(werte: {
|
||||
name: string;
|
||||
email: string;
|
||||
passwort: string;
|
||||
rolle: Rolle;
|
||||
}): Promise<Benutzer> {
|
||||
const id = crypto.randomUUID();
|
||||
const datensatz = {
|
||||
id,
|
||||
name: werte.name.trim(),
|
||||
email: werte.email.trim().toLowerCase(),
|
||||
passwortHash: await passwortHashen(werte.passwort),
|
||||
rolle: werte.rolle,
|
||||
aktiv: 1,
|
||||
erstelltAm: jetzt(),
|
||||
letzteAnmeldungAm: null,
|
||||
} satisfies Benutzer;
|
||||
|
||||
datenbank().insert(schema.benutzer).values(datensatz).run();
|
||||
return datensatz;
|
||||
}
|
||||
|
||||
export async function passwortSetzen(benutzerId: string, neuesPasswort: string): Promise<void> {
|
||||
const hash = await passwortHashen(neuesPasswort);
|
||||
datenbank().update(schema.benutzer).set({ passwortHash: hash }).where(eq(schema.benutzer.id, benutzerId)).run();
|
||||
// Alle bestehenden Sitzungen dieses Kontos verfallen.
|
||||
datenbank().delete(schema.sitzung).where(eq(schema.sitzung.benutzerId, benutzerId)).run();
|
||||
}
|
||||
|
||||
export function aktivSetzen(benutzerId: string, aktiv: boolean): void {
|
||||
datenbank()
|
||||
.update(schema.benutzer)
|
||||
.set({ aktiv: aktiv ? 1 : 0 })
|
||||
.where(eq(schema.benutzer.id, benutzerId))
|
||||
.run();
|
||||
if (!aktiv) {
|
||||
datenbank().delete(schema.sitzung).where(eq(schema.sitzung.benutzerId, benutzerId)).run();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,121 @@
|
||||
/**
|
||||
* Zeitrechnung der Anwendung.
|
||||
*
|
||||
* Zeitstempel werden als ISO-8601 in UTC gespeichert (mit `Z`), also als
|
||||
* eindeutiger Zeitpunkt. Angezeigt wird immer in Europe/Berlin.
|
||||
* Reine Kalenderdaten (Berichtszeitraum, Tagesnotiz) sind `YYYY-MM-DD`.
|
||||
*/
|
||||
|
||||
export const ZEITZONE = 'Europe/Berlin';
|
||||
|
||||
/** Aktueller Zeitpunkt als ISO-8601 in UTC. */
|
||||
export function jetzt(): string {
|
||||
return new Date().toISOString();
|
||||
}
|
||||
|
||||
/** Heutiges Kalenderdatum in Europe/Berlin als `YYYY-MM-DD`. */
|
||||
export function heute(bezug: Date = new Date()): string {
|
||||
return alsDatum(bezug);
|
||||
}
|
||||
|
||||
/** Ein Zeitpunkt als Kalenderdatum in Europe/Berlin. */
|
||||
export function alsDatum(zeitpunkt: Date | string): string {
|
||||
const d = typeof zeitpunkt === 'string' ? new Date(zeitpunkt) : zeitpunkt;
|
||||
const teile = new Intl.DateTimeFormat('sv-SE', {
|
||||
timeZone: ZEITZONE,
|
||||
year: 'numeric',
|
||||
month: '2-digit',
|
||||
day: '2-digit',
|
||||
}).format(d);
|
||||
return teile; // sv-SE liefert genau YYYY-MM-DD
|
||||
}
|
||||
|
||||
/** Datum und Uhrzeit für die Anzeige, z. B. „10.09.2026, 08:15". */
|
||||
export function alsZeitpunktText(zeitpunkt: Date | string | null | undefined): string {
|
||||
if (!zeitpunkt) return '–';
|
||||
const d = typeof zeitpunkt === 'string' ? new Date(zeitpunkt) : zeitpunkt;
|
||||
return new Intl.DateTimeFormat('de-DE', {
|
||||
timeZone: ZEITZONE,
|
||||
dateStyle: 'short',
|
||||
timeStyle: 'short',
|
||||
}).format(d);
|
||||
}
|
||||
|
||||
/** Datum für die Anzeige, z. B. „10.09.2026". */
|
||||
export function alsDatumText(datum: string | null | undefined): string {
|
||||
if (!datum) return '–';
|
||||
const d = new Date(`${datum}T12:00:00Z`);
|
||||
return new Intl.DateTimeFormat('de-DE', { timeZone: ZEITZONE, dateStyle: 'short' }).format(d);
|
||||
}
|
||||
|
||||
/** Wochentagsname, z. B. „Montag". */
|
||||
export function wochentagText(datum: string): string {
|
||||
const d = new Date(`${datum}T12:00:00Z`);
|
||||
return new Intl.DateTimeFormat('de-DE', { timeZone: ZEITZONE, weekday: 'long' }).format(d);
|
||||
}
|
||||
|
||||
// --- Kalenderrechnung auf reinen Datumsstrings (UTC-Mittag als Anker) ---
|
||||
|
||||
function zuDate(datum: string): Date {
|
||||
return new Date(`${datum}T12:00:00Z`);
|
||||
}
|
||||
|
||||
function zuString(d: Date): string {
|
||||
return d.toISOString().slice(0, 10);
|
||||
}
|
||||
|
||||
/** Tage addieren (auch negativ). */
|
||||
export function plusTage(datum: string, tage: number): string {
|
||||
const d = zuDate(datum);
|
||||
d.setUTCDate(d.getUTCDate() + tage);
|
||||
return zuString(d);
|
||||
}
|
||||
|
||||
/** Montag der Woche, in der das Datum liegt. */
|
||||
export function montagDerWoche(datum: string): string {
|
||||
const d = zuDate(datum);
|
||||
const wochentag = (d.getUTCDay() + 6) % 7; // Montag = 0
|
||||
d.setUTCDate(d.getUTCDate() - wochentag);
|
||||
return zuString(d);
|
||||
}
|
||||
|
||||
/** Freitag der Woche, in der das Datum liegt. */
|
||||
export function freitagDerWoche(datum: string): string {
|
||||
return plusTage(montagDerWoche(datum), 4);
|
||||
}
|
||||
|
||||
/** Kalenderwoche nach ISO 8601 (Woche 1 enthält den ersten Donnerstag). */
|
||||
export function isoKalenderwoche(datum: string): number {
|
||||
const d = zuDate(datum);
|
||||
const wochentag = (d.getUTCDay() + 6) % 7;
|
||||
d.setUTCDate(d.getUTCDate() - wochentag + 3); // Donnerstag dieser Woche
|
||||
const donnerstag = d.getTime();
|
||||
const jahresanfang = new Date(Date.UTC(d.getUTCFullYear(), 0, 4, 12, 0, 0));
|
||||
const wochentagAnfang = (jahresanfang.getUTCDay() + 6) % 7;
|
||||
jahresanfang.setUTCDate(jahresanfang.getUTCDate() - wochentagAnfang + 3);
|
||||
return 1 + Math.round((donnerstag - jahresanfang.getTime()) / (7 * 24 * 3600 * 1000));
|
||||
}
|
||||
|
||||
/** Kalenderjahr nach ISO 8601 – kann am Jahreswechsel vom Kalenderjahr abweichen. */
|
||||
export function isoKalenderjahr(datum: string): number {
|
||||
const d = zuDate(datum);
|
||||
const wochentag = (d.getUTCDay() + 6) % 7;
|
||||
d.setUTCDate(d.getUTCDate() - wochentag + 3);
|
||||
return d.getUTCFullYear();
|
||||
}
|
||||
|
||||
/** „KW 37 / 2026" */
|
||||
export function kalenderwocheText(datum: string): string {
|
||||
return `KW ${String(isoKalenderwoche(datum)).padStart(2, '0')} / ${isoKalenderjahr(datum)}`;
|
||||
}
|
||||
|
||||
/** Die fünf Werktage (Mo–Fr) der Woche eines Datums. */
|
||||
export function werktage(datum: string): string[] {
|
||||
const montag = montagDerWoche(datum);
|
||||
return [0, 1, 2, 3, 4].map((n) => plusTage(montag, n));
|
||||
}
|
||||
|
||||
/** Zeitpunkt in der Zukunft, für Sitzungsablauf. */
|
||||
export function inTagen(tage: number, bezug: Date = new Date()): string {
|
||||
return new Date(bezug.getTime() + tage * 24 * 3600 * 1000).toISOString();
|
||||
}
|
||||
@@ -0,0 +1,78 @@
|
||||
import { describe, expect, it } from 'vitest';
|
||||
import {
|
||||
alsDatum,
|
||||
freitagDerWoche,
|
||||
isoKalenderjahr,
|
||||
isoKalenderwoche,
|
||||
kalenderwocheText,
|
||||
montagDerWoche,
|
||||
plusTage,
|
||||
werktage,
|
||||
} from './index';
|
||||
|
||||
describe('ISO-Kalenderwochen', () => {
|
||||
it('rechnet gewöhnliche Wochen richtig', () => {
|
||||
expect(isoKalenderwoche('2026-09-10')).toBe(37);
|
||||
expect(isoKalenderjahr('2026-09-10')).toBe(2026);
|
||||
});
|
||||
|
||||
it('rechnet den Jahreswechsel nach ISO 8601, nicht nach Kalenderjahr', () => {
|
||||
// 1. Januar 2027 ist ein Freitag – gehört noch zur 53. Woche von 2026.
|
||||
expect(isoKalenderwoche('2027-01-01')).toBe(53);
|
||||
expect(isoKalenderjahr('2027-01-01')).toBe(2026);
|
||||
|
||||
// 31. Dezember 2019 ist ein Dienstag – gehört schon zur 1. Woche von 2020.
|
||||
expect(isoKalenderwoche('2019-12-31')).toBe(1);
|
||||
expect(isoKalenderjahr('2019-12-31')).toBe(2020);
|
||||
|
||||
// 4. Januar liegt per Definition immer in Woche 1.
|
||||
expect(isoKalenderwoche('2021-01-04')).toBe(1);
|
||||
expect(isoKalenderjahr('2021-01-04')).toBe(2021);
|
||||
});
|
||||
|
||||
it('kennt Jahre mit 53 Wochen', () => {
|
||||
expect(isoKalenderwoche('2020-12-31')).toBe(53);
|
||||
expect(isoKalenderjahr('2020-12-31')).toBe(2020);
|
||||
});
|
||||
|
||||
it('beschriftet zweistellig', () => {
|
||||
expect(kalenderwocheText('2026-01-05')).toBe('KW 02 / 2026');
|
||||
});
|
||||
});
|
||||
|
||||
describe('Wochenrechnung', () => {
|
||||
it('findet Montag und Freitag – auch wenn das Datum selbst ein Sonntag ist', () => {
|
||||
expect(montagDerWoche('2026-09-10')).toBe('2026-09-07'); // Donnerstag
|
||||
expect(montagDerWoche('2026-09-13')).toBe('2026-09-07'); // Sonntag
|
||||
expect(montagDerWoche('2026-09-07')).toBe('2026-09-07'); // Montag selbst
|
||||
expect(freitagDerWoche('2026-09-13')).toBe('2026-09-11');
|
||||
});
|
||||
|
||||
it('liefert genau die fünf Werktage', () => {
|
||||
expect(werktage('2026-09-10')).toEqual([
|
||||
'2026-09-07',
|
||||
'2026-09-08',
|
||||
'2026-09-09',
|
||||
'2026-09-10',
|
||||
'2026-09-11',
|
||||
]);
|
||||
});
|
||||
|
||||
it('rechnet über Monats- und Jahresgrenzen', () => {
|
||||
expect(plusTage('2026-02-28', 1)).toBe('2026-03-01');
|
||||
expect(plusTage('2024-02-28', 1)).toBe('2024-02-29'); // Schaltjahr
|
||||
expect(plusTage('2026-01-01', -1)).toBe('2025-12-31');
|
||||
expect(plusTage('2026-12-31', 1)).toBe('2027-01-01');
|
||||
});
|
||||
});
|
||||
|
||||
describe('Zeitzone Europe/Berlin', () => {
|
||||
it('ordnet einen Zeitpunkt dem richtigen Kalendertag zu', () => {
|
||||
// 22:30 UTC am 9.9. ist in Berlin (Sommerzeit, UTC+2) schon der 10.9.
|
||||
expect(alsDatum('2026-09-09T22:30:00.000Z')).toBe('2026-09-10');
|
||||
// 22:30 UTC im Winter (UTC+1) ist noch der 9.12.
|
||||
expect(alsDatum('2026-12-09T22:30:00.000Z')).toBe('2026-12-09');
|
||||
// 23:30 UTC im Winter ist der 10.12.
|
||||
expect(alsDatum('2026-12-09T23:30:00.000Z')).toBe('2026-12-10');
|
||||
});
|
||||
});
|
||||
Reference in New Issue
Block a user