From c703d87a1ce83705dec6673f8605d6a4836b6be0 Mon Sep 17 00:00:00 2001 From: Schalli Date: Tue, 29 Sep 2026 10:09:08 +0200 Subject: [PATCH] feat(260929-dzu): persoenliche eigene Module je Benutzer (API, Migration, Zeilenschutz) - ownerUserId (NULL = gemeinsam, sonst persoenlich) mit Zeilenschutz nach Muster SearchProvider - GET nur gemeinsame + eigene, fremde persoenliche Eintraege 404 - POST fuer jeden Benutzer, shared nur fuer Administratoren (403) - PATCH/DELETE: persoenlich nur Besitzer, gemeinsam nur Administrator - Zugriffsklassifikation nachgemessen: 61/223/6 Co-Authored-By: Claude Opus 5.5 (1M context) --- .../migration.sql | 77 +++++ apps/api/prisma/schema.prisma | 7 + .../custom-modules.controller.spec.ts | 70 +++-- .../custom-modules.controller.ts | 51 ++-- .../custom-modules.service.spec.ts | 267 ++++++++++++++---- .../custom-modules/custom-modules.service.ts | 177 +++++++++--- .../custom-modules/dto/custom-module.dto.ts | 24 +- ...andantentrennung-zugriffsklassifikation.md | 10 +- 8 files changed, 533 insertions(+), 150 deletions(-) create mode 100644 apps/api/prisma/migrations/20260929130000_custom_module_owner/migration.sql diff --git a/apps/api/prisma/migrations/20260929130000_custom_module_owner/migration.sql b/apps/api/prisma/migrations/20260929130000_custom_module_owner/migration.sql new file mode 100644 index 0000000..943e8c4 --- /dev/null +++ b/apps/api/prisma/migrations/20260929130000_custom_module_owner/migration.sql @@ -0,0 +1,77 @@ +-- 260929-dzu — Eigene Module fuer jeden Benutzer: persoenliche Eintraege. +-- +-- Zweck: jeder Benutzer darf eigene Seitenleisten-Eintraege anlegen, die nur +-- er selbst sieht. Die Spalte "ownerUserId" unterscheidet: NULL = gemeinsamer +-- Eintrag (vom Administrator, fuer alle sichtbar, bisheriges Verhalten), +-- gesetzt = persoenlicher Eintrag dieses Benutzers. Faellt der Benutzer weg, +-- fallen seine Eintraege mit (ON DELETE CASCADE). Bestehende Zeilen bleiben +-- gemeinsam (NULL). +-- +-- Zeilenschutz: Muster "SearchProvider" (20260911120000_rls_user_dimension_ +-- personal_tables) — Spalte mit NULL = gemeinsame Zeile. Die eine Regel +-- "tenant_isolation_policy" (aus 20260929120000, ohne Benutzerdimension) wird +-- durch vier nach Befehl getrennte Regeln ersetzt (Praezedenz 260910-jab (3)): +-- ein einzelner USING-Ausdruck, der die gemeinsame Zeile zum Lesen einschliesst, +-- wuerde sie sonst auch zum Aendern/Entfernen freigeben. +-- SELECT: Mandant UND (kein Benutzer gesetzt ODER gemeinsame Zeile ODER +-- eigene Zeile). +-- INSERT/UPDATE/DELETE: Mandant UND (kein Benutzer gesetzt ODER eigene +-- Zeile). Ein Benutzerkontext kann gemeinsame Zeilen also NICHT +-- schreiben; der Administrator-Weg fuer gemeinsame Eintraege bindet +-- deshalb ohne Benutzer (`forTenant(prisma, tenantId)`), die +-- Rollenpruefung liegt im Controller/Dienst. +-- Die Regelnamen sind neu (vier statt eine), rls-coverage.spec.ts fordert nur +-- mindestens eine Regel je Tabelle mit eingeschaltetem RLS. +-- +-- Rechte fuer tessera_app kommen ueber ALTER DEFAULT PRIVILEGES aus +-- 20260909130000_rls_app_role — hier nichts zu tun. +-- +-- WICHTIG: wie alle RLS-Regeln dieses Schemas wirken diese erst, wenn die +-- Anwendung als Rolle ohne Umgehungsrecht verbindet (Schalter heute AUS, siehe +-- docs/mandantentrennung-datenbankrolle.md). Bis dahin tragen die +-- Anwendungspruefungen im Dienst den Schutz allein. + +ALTER TABLE "CustomModule" ADD COLUMN "ownerUserId" TEXT; + +CREATE INDEX "CustomModule_tenantId_ownerUserId_idx" ON "CustomModule"("tenantId", "ownerUserId"); + +ALTER TABLE "CustomModule" ADD CONSTRAINT "CustomModule_ownerUserId_fkey" + FOREIGN KEY ("ownerUserId") REFERENCES "User"("id") ON DELETE CASCADE ON UPDATE CASCADE; + +DROP POLICY tenant_isolation_policy ON "CustomModule"; + +CREATE POLICY tenant_user_read_policy ON "CustomModule" + FOR SELECT + USING ( + "tenantId" = current_tenant_id() + AND ( + current_user_id() IS NULL + OR "ownerUserId" IS NULL + OR "ownerUserId" = current_user_id() + ) + ); + +CREATE POLICY tenant_user_insert_policy ON "CustomModule" + FOR INSERT + WITH CHECK ( + "tenantId" = current_tenant_id() + AND (current_user_id() IS NULL OR "ownerUserId" = current_user_id()) + ); + +CREATE POLICY tenant_user_update_policy ON "CustomModule" + FOR UPDATE + USING ( + "tenantId" = current_tenant_id() + AND (current_user_id() IS NULL OR "ownerUserId" = current_user_id()) + ) + WITH CHECK ( + "tenantId" = current_tenant_id() + AND (current_user_id() IS NULL OR "ownerUserId" = current_user_id()) + ); + +CREATE POLICY tenant_user_delete_policy ON "CustomModule" + FOR DELETE + USING ( + "tenantId" = current_tenant_id() + AND (current_user_id() IS NULL OR "ownerUserId" = current_user_id()) + ); diff --git a/apps/api/prisma/schema.prisma b/apps/api/prisma/schema.prisma index c464294..4efa9cf 100644 --- a/apps/api/prisma/schema.prisma +++ b/apps/api/prisma/schema.prisma @@ -53,6 +53,7 @@ model User { passwordResetTokens PasswordResetToken[] groupMemberships GroupMembership[] moduleGrants ModuleGrant[] + customModules CustomModule[] @@index([tenantId]) @@index([username]) @@ -727,8 +728,14 @@ model CustomModule { name String url String category String // eine der MODULE_CATEGORIES aus @tessera/shared + // quick-260929-dzu: null = gemeinsamer Eintrag (vom Administrator, fuer alle + // sichtbar); gesetzt = persoenlicher Eintrag, nur fuer diesen Benutzer + // sichtbar. Faellt der Benutzer weg, fallen seine Eintraege mit. + ownerUserId String? + owner User? @relation(fields: [ownerUserId], references: [id], onDelete: Cascade) createdAt DateTime @default(now()) updatedAt DateTime @updatedAt @@index([tenantId]) + @@index([tenantId, ownerUserId]) } diff --git a/apps/api/src/custom-modules/custom-modules.controller.spec.ts b/apps/api/src/custom-modules/custom-modules.controller.spec.ts index 23c4201..e66119e 100644 --- a/apps/api/src/custom-modules/custom-modules.controller.spec.ts +++ b/apps/api/src/custom-modules/custom-modules.controller.spec.ts @@ -1,10 +1,9 @@ import 'reflect-metadata'; import { ForbiddenException, ValidationPipe } from '@nestjs/common'; -import { Role } from '@prisma/client'; import { describe, expect, it, vi } from 'vitest'; import { ROLES_KEY } from '../auth/decorators/roles.decorator'; import { CustomModulesController } from './custom-modules.controller'; -import { CreateCustomModuleDto } from './dto/custom-module.dto'; +import { CreateCustomModuleDto, UpdateCustomModuleDto } from './dto/custom-module.dto'; function makeService() { return { @@ -17,14 +16,20 @@ function makeService() { } const req = (tenantId?: string) => ({ tenantId }) as any; +const user = { id: 'u1', username: 'u', role: 'USER', tenantId: 't1' } as any; const proto = CustomModulesController.prototype as any; -describe('CustomModulesController — Rollen (T-9WC-01)', () => { - it.each(['create', 'update', 'remove'])('%s ist nur fuer ADMIN und SUPER_ADMIN offen', (name) => { - expect(Reflect.getMetadata(ROLES_KEY, proto[name])).toEqual([Role.ADMIN, Role.SUPER_ADMIN]); - }); - - it.each(['list', 'getOne'])('%s traegt keine Rollen (jeder Angemeldete)', (name) => { +describe('CustomModulesController — Rollen (quick-260929-dzu)', () => { + // Jeder Angemeldete darf persoenliche Eintraege anlegen/aendern/loeschen; die + // Administrator-Pflicht fuer gemeinsame Eintraege prueft der Dienst (hangt + // vom Eintrag ab, nicht von der Route) — siehe custom-modules.service.spec.ts. + it.each([ + 'list', + 'getOne', + 'create', + 'update', + 'remove', + ])('%s traegt keine Routen-Rolle (jeder Angemeldete)', (name) => { expect(Reflect.getMetadata(ROLES_KEY, proto[name])).toBeUndefined(); }); @@ -37,26 +42,26 @@ describe('CustomModulesController — Mandant', () => { it('reicht req.tenantId an den Dienst weiter', async () => { const service = makeService(); const controller = new CustomModulesController(service as any); - await controller.list(req('t1')); - await controller.getOne(req('t1'), 'x'); - await controller.create(req('t1'), { name: 'a', url: 'https://a.de', category: 'fleet' }); - await controller.update(req('t1'), 'x', { name: 'b' }); - await controller.remove(req('t1'), 'x'); - expect(service.list).toHaveBeenCalledWith('t1'); - expect(service.getOne).toHaveBeenCalledWith('t1', 'x'); - expect(service.create.mock.calls[0][0]).toBe('t1'); - expect(service.update.mock.calls[0].slice(0, 2)).toEqual(['t1', 'x']); - expect(service.remove).toHaveBeenCalledWith('t1', 'x'); + await controller.list(req('t1'), user); + await controller.getOne(req('t1'), user, 'x'); + await controller.create(req('t1'), user, { name: 'a', url: 'https://a.de', category: 'fleet' }); + await controller.update(req('t1'), user, 'x', { name: 'b' }); + await controller.remove(req('t1'), user, 'x'); + expect(service.list).toHaveBeenCalledWith('t1', user); + expect(service.getOne).toHaveBeenCalledWith('t1', user, 'x'); + expect(service.create.mock.calls[0].slice(0, 2)).toEqual(['t1', user]); + expect(service.update.mock.calls[0].slice(0, 3)).toEqual(['t1', user, 'x']); + expect(service.remove).toHaveBeenCalledWith('t1', user, 'x'); }); it('wirft ForbiddenException ohne req.tenantId', async () => { const controller = new CustomModulesController(makeService() as any); - await expect(controller.list(req())).rejects.toBeInstanceOf(ForbiddenException); - await expect(controller.getOne(req(), 'x')).rejects.toBeInstanceOf(ForbiddenException); + await expect(controller.list(req(), user)).rejects.toBeInstanceOf(ForbiddenException); + await expect(controller.getOne(req(), user, 'x')).rejects.toBeInstanceOf(ForbiddenException); await expect( - controller.create(req(), { name: 'a', url: 'https://a.de', category: 'fleet' }), + controller.create(req(), user, { name: 'a', url: 'https://a.de', category: 'fleet' }), ).rejects.toBeInstanceOf(ForbiddenException); - await expect(controller.remove(req(), 'x')).rejects.toBeInstanceOf(ForbiddenException); + await expect(controller.remove(req(), user, 'x')).rejects.toBeInstanceOf(ForbiddenException); }); it('die globale Pipe verwirft ein untergeschobenes tenantId (T-9WC-07)', async () => { @@ -67,6 +72,27 @@ describe('CustomModulesController — Mandant', () => { ); expect(out).not.toHaveProperty('tenantId'); }); + + it('die globale Pipe verwirft ownerUserId, laesst shared beim Anlegen durch', async () => { + const pipe = new ValidationPipe({ whitelist: true, transform: true }); + const out: any = await pipe.transform( + { name: 'a', url: 'https://a.de', category: 'fleet', ownerUserId: 'evil', shared: true }, + { type: 'body', metatype: CreateCustomModuleDto }, + ); + expect(out).not.toHaveProperty('ownerUserId'); + expect(out.shared).toBe(true); + }); + + it('die globale Pipe verwirft shared und ownerUserId beim Aendern', async () => { + const pipe = new ValidationPipe({ whitelist: true, transform: true }); + const out: any = await pipe.transform( + { name: 'b', shared: true, ownerUserId: 'evil' }, + { type: 'body', metatype: UpdateCustomModuleDto }, + ); + expect(out).not.toHaveProperty('shared'); + expect(out).not.toHaveProperty('ownerUserId'); + expect(out.name).toBe('b'); + }); }); describe('CustomModulesController — Routen-Reihenfolge (statisch vor :id)', () => { diff --git a/apps/api/src/custom-modules/custom-modules.controller.ts b/apps/api/src/custom-modules/custom-modules.controller.ts index f788130..a8e0d27 100644 --- a/apps/api/src/custom-modules/custom-modules.controller.ts +++ b/apps/api/src/custom-modules/custom-modules.controller.ts @@ -9,18 +9,21 @@ import { Post, Req, } from '@nestjs/common'; -import { Role } from '@prisma/client'; -import { Roles } from '../auth/decorators/roles.decorator'; -import type { AuthenticatedRequest } from '../auth/types/auth-user'; +import { CurrentUser } from '../auth/decorators/current-user.decorator'; +import type { AuthenticatedRequest, AuthUser } from '../auth/types/auth-user'; import { CustomModulesService } from './custom-modules.service'; import { CreateCustomModuleDto, UpdateCustomModuleDto } from './dto/custom-module.dto'; /** - * Eigene Module (quick-260929-9wc). Lesen (`GET`, `GET :id`) steht jedem - * angemeldeten Benutzer offen — die Eintraege sind fuer alle sichtbar (D-01); - * Schreiben nur `@Roles(ADMIN, SUPER_ADMIN)` (T-9WC-01). Kein `@UseModule`: + * Eigene Module (quick-260929-9wc, erweitert in quick-260929-dzu). Jeder + * angemeldete Benutzer darf lesen und eigene (persoenliche) Eintraege anlegen, + * aendern und loeschen; gemeinsame Eintraege (`shared: true`) darf nur ein + * Administrator anlegen, aendern und loeschen — diese Rollenentscheidung trifft + * der Dienst, weil sie vom Eintrag abhaengt (gemeinsam oder persoenlich), nicht + * von der Route. Deshalb tragen die Routen kein `@Roles`. Kein `@UseModule`: * eigene Module haengen an keiner Modul-Aktivierung. `tenantId` kommt - * ausschliesslich aus `req.tenantId` (gesetzt vom `TenantGuard`). + * ausschliesslich aus `req.tenantId` (gesetzt vom `TenantGuard`), der Benutzer + * aus dem Token. * * ROUTEN-REIHENFOLGE: NestJS bildet Routen in Deklarationsreihenfolge ab. * Jede kuenftige statische GET-Route MUSS ueber `getOne` (`@Get(':id')`) @@ -40,34 +43,44 @@ export class CustomModulesController { } @Get() - async list(@Req() req: AuthenticatedRequest) { - return this.service.list(this.requireTenantId(req)); + async list(@Req() req: AuthenticatedRequest, @CurrentUser() user: AuthUser) { + return this.service.list(this.requireTenantId(req), user); } @Get(':id') - async getOne(@Req() req: AuthenticatedRequest, @Param('id') id: string) { - return this.service.getOne(this.requireTenantId(req), id); + async getOne( + @Req() req: AuthenticatedRequest, + @CurrentUser() user: AuthUser, + @Param('id') id: string, + ) { + return this.service.getOne(this.requireTenantId(req), user, id); } @Post() - @Roles(Role.ADMIN, Role.SUPER_ADMIN) - async create(@Req() req: AuthenticatedRequest, @Body() dto: CreateCustomModuleDto) { - return this.service.create(this.requireTenantId(req), dto); + async create( + @Req() req: AuthenticatedRequest, + @CurrentUser() user: AuthUser, + @Body() dto: CreateCustomModuleDto, + ) { + return this.service.create(this.requireTenantId(req), user, dto); } @Patch(':id') - @Roles(Role.ADMIN, Role.SUPER_ADMIN) async update( @Req() req: AuthenticatedRequest, + @CurrentUser() user: AuthUser, @Param('id') id: string, @Body() dto: UpdateCustomModuleDto, ) { - return this.service.update(this.requireTenantId(req), id, dto); + return this.service.update(this.requireTenantId(req), user, id, dto); } @Delete(':id') - @Roles(Role.ADMIN, Role.SUPER_ADMIN) - async remove(@Req() req: AuthenticatedRequest, @Param('id') id: string) { - return this.service.remove(this.requireTenantId(req), id); + async remove( + @Req() req: AuthenticatedRequest, + @CurrentUser() user: AuthUser, + @Param('id') id: string, + ) { + return this.service.remove(this.requireTenantId(req), user, id); } } diff --git a/apps/api/src/custom-modules/custom-modules.service.spec.ts b/apps/api/src/custom-modules/custom-modules.service.spec.ts index 3a0ced8..d4e312e 100644 --- a/apps/api/src/custom-modules/custom-modules.service.spec.ts +++ b/apps/api/src/custom-modules/custom-modules.service.spec.ts @@ -1,9 +1,10 @@ -import { NotFoundException } from '@nestjs/common'; +import { ForbiddenException, NotFoundException } from '@nestjs/common'; +import { Role } from '@prisma/client'; import { describe, expect, it, vi } from 'vitest'; // `forTenant` reicht den Klienten durch — Mandantenbindung selbst prueft -// rls-access-inventory.spec.ts; hier zaehlt, dass je Methode (prisma, tenantId) -// uebergeben wird. +// rls-access-inventory.spec.ts; hier zaehlt, mit welchen Argumenten je Methode +// gebunden wird (mit oder ohne Benutzer). vi.mock('../prisma/prisma-tenant.extension', () => ({ forTenant: vi.fn((p: unknown) => p), })); @@ -24,6 +25,11 @@ function makeFakePrisma() { findMany: vi.fn(async ({ where, orderBy }: { where?: any; orderBy?: any } = {}) => { let list = [...rows.values()]; if (where?.tenantId) list = list.filter((r) => r.tenantId === where.tenantId); + if (where?.OR) { + list = list.filter((r) => + where.OR.some((c: { ownerUserId: string | null }) => r.ownerUserId === c.ownerUserId), + ); + } if (orderBy?.name === 'asc') list.sort((a, b) => a.name.localeCompare(b.name)); return list; }), @@ -41,86 +47,233 @@ function makeFakePrisma() { } const dto = { name: 'Wiki', url: 'https://example.com', category: 'infrastructure' as const }; +const admin = { id: 'admin1', role: Role.ADMIN }; +const userA = { id: 'ua', role: Role.USER }; +const userB = { id: 'ub', role: Role.USER }; -describe('CustomModulesService', () => { - it('create speichert tenantId aus dem Argument, nie aus dem DTO', async () => { - const prisma = makeFakePrisma(); - const service = new CustomModulesService(prisma as any); - await service.create('t1', { ...dto, tenantId: 'evil' } as any); - expect(prisma.customModule.create).toHaveBeenCalledTimes(1); +function setup() { + const prisma = makeFakePrisma(); + return { prisma, service: new CustomModulesService(prisma as any) }; +} + +describe('CustomModulesService — anlegen', () => { + it('speichert tenantId aus dem Argument, nie aus dem DTO', async () => { + const { prisma, service } = setup(); + await service.create('t1', userA, { ...dto, tenantId: 'evil' } as any); expect(prisma.customModule.create.mock.calls[0][0].data.tenantId).toBe('t1'); }); - it('list liefert nur Zeilen des Mandanten, nach Name sortiert', async () => { - const prisma = makeFakePrisma(); - const service = new CustomModulesService(prisma as any); - await service.create('t1', { ...dto, name: 'Zebra' }); - await service.create('t1', { ...dto, name: 'Anker' }); - await service.create('t2', { ...dto, name: 'Fremd' }); - const result = await service.list('t1'); - expect(result.map((r: any) => r.name)).toEqual(['Anker', 'Zebra']); - expect(prisma.customModule.findMany.mock.calls[0]?.[0]?.where).toEqual({ tenantId: 't1' }); + it('ohne shared-Angabe ist der Eintrag persoenlich (ownerUserId = Aufrufer)', async () => { + const { prisma, service } = setup(); + const res: any = await service.create('t1', userA, dto); + expect(prisma.customModule.create.mock.calls[0][0].data.ownerUserId).toBe('ua'); + expect(res.personal).toBe(true); + expect(res).not.toHaveProperty('ownerUserId'); }); - it('getOne liefert die Zeile ohne tenantId', async () => { - const prisma = makeFakePrisma(); - const service = new CustomModulesService(prisma as any); - const created: any = await service.create('t1', dto); - const row: any = await service.getOne('t1', created.id); + it('auch ein Administrator legt ohne shared persoenlich an', async () => { + const { prisma, service } = setup(); + const res: any = await service.create('t1', admin, dto); + expect(prisma.customModule.create.mock.calls[0][0].data.ownerUserId).toBe('admin1'); + expect(res.personal).toBe(true); + }); + + it('shared: true durch einen Administrator legt einen gemeinsamen Eintrag an', async () => { + const { prisma, service } = setup(); + const res: any = await service.create('t1', admin, { ...dto, shared: true }); + expect(prisma.customModule.create.mock.calls[0][0].data.ownerUserId).toBeNull(); + expect(res.personal).toBe(false); + }); + + it('shared: true durch einen normalen Benutzer -> ForbiddenException, nichts gespeichert', async () => { + const { prisma, service } = setup(); + await expect(service.create('t1', userA, { ...dto, shared: true })).rejects.toBeInstanceOf( + ForbiddenException, + ); + expect(prisma.customModule.create).not.toHaveBeenCalled(); + }); + + it('shared: false durch einen normalen Benutzer bleibt persoenlich', async () => { + const { prisma, service } = setup(); + await service.create('t1', userA, { ...dto, shared: false }); + expect(prisma.customModule.create.mock.calls[0][0].data.ownerUserId).toBe('ua'); + }); + + it('das Feld shared landet nie in den gespeicherten Daten', async () => { + const { prisma, service } = setup(); + await service.create('t1', admin, { ...dto, shared: true }); + expect(prisma.customModule.create.mock.calls[0][0].data).not.toHaveProperty('shared'); + }); +}); + +describe('CustomModulesService — lesen', () => { + it('list liefert gemeinsame plus eigene Eintraege, nie die eines anderen Benutzers', async () => { + const { service } = setup(); + await service.create('t1', admin, { ...dto, name: 'Gemeinsam', shared: true }); + await service.create('t1', userA, { ...dto, name: 'A-privat' }); + await service.create('t1', userB, { ...dto, name: 'B-privat' }); + const resA: any[] = await service.list('t1', userA); + expect(resA.map((r) => [r.name, r.personal])).toEqual([ + ['A-privat', true], + ['Gemeinsam', false], + ]); + const resB: any[] = await service.list('t1', userB); + expect(resB.map((r) => r.name)).toEqual(['B-privat', 'Gemeinsam']); + }); + + it('list sieht auch als Administrator keine persoenlichen Eintraege anderer', async () => { + const { service } = setup(); + await service.create('t1', userA, { ...dto, name: 'A-privat' }); + await service.create('t1', admin, { ...dto, name: 'Gemeinsam', shared: true }); + const res: any[] = await service.list('t1', admin); + expect(res.map((r) => r.name)).toEqual(['Gemeinsam']); + }); + + it('list liefert nur Zeilen des Mandanten, nach Name sortiert', async () => { + const { prisma, service } = setup(); + await service.create('t1', admin, { ...dto, name: 'Zebra', shared: true }); + await service.create('t1', admin, { ...dto, name: 'Anker', shared: true }); + await service.create('t2', admin, { ...dto, name: 'Fremd', shared: true }); + const result: any[] = await service.list('t1', userA); + expect(result.map((r) => r.name)).toEqual(['Anker', 'Zebra']); + expect(prisma.customModule.findMany.mock.calls[0]?.[0]?.where).toEqual({ + tenantId: 't1', + OR: [{ ownerUserId: null }, { ownerUserId: 'ua' }], + }); + }); + + it('getOne liefert einen gemeinsamen Eintrag jedem, ohne tenantId und ownerUserId', async () => { + const { service } = setup(); + const created: any = await service.create('t1', admin, { ...dto, shared: true }); + const row: any = await service.getOne('t1', userA, created.id); expect(row.name).toBe('Wiki'); + expect(row.personal).toBe(false); expect(row).not.toHaveProperty('tenantId'); + expect(row).not.toHaveProperty('ownerUserId'); + }); + + it('getOne liefert einen eigenen persoenlichen Eintrag', async () => { + const { service } = setup(); + const created: any = await service.create('t1', userA, dto); + const row: any = await service.getOne('t1', userA, created.id); + expect(row.personal).toBe(true); + }); + + it('getOne auf den persoenlichen Eintrag eines anderen -> NotFoundException (auch fuer Administratoren)', async () => { + const { service } = setup(); + const created: any = await service.create('t1', userA, dto); + await expect(service.getOne('t1', userB, created.id)).rejects.toBeInstanceOf(NotFoundException); + await expect(service.getOne('t1', admin, created.id)).rejects.toBeInstanceOf(NotFoundException); }); it('getOne/update/remove mit unbekannter id -> NotFoundException', async () => { - const service = new CustomModulesService(makeFakePrisma() as any); - await expect(service.getOne('t1', 'nope')).rejects.toBeInstanceOf(NotFoundException); - await expect(service.update('t1', 'nope', { name: 'x' })).rejects.toBeInstanceOf( + const { service } = setup(); + await expect(service.getOne('t1', userA, 'nope')).rejects.toBeInstanceOf(NotFoundException); + await expect(service.update('t1', userA, 'nope', { name: 'x' })).rejects.toBeInstanceOf( NotFoundException, ); - await expect(service.remove('t1', 'nope')).rejects.toBeInstanceOf(NotFoundException); + await expect(service.remove('t1', userA, 'nope')).rejects.toBeInstanceOf(NotFoundException); }); it('getOne/update/remove mit Zeile eines anderen Mandanten -> NotFoundException', async () => { - const prisma = makeFakePrisma(); - const service = new CustomModulesService(prisma as any); - const created: any = await service.create('t2', dto); - await expect(service.getOne('t1', created.id)).rejects.toBeInstanceOf(NotFoundException); - await expect(service.update('t1', created.id, { name: 'x' })).rejects.toBeInstanceOf( + const { prisma, service } = setup(); + const created: any = await service.create('t2', admin, { ...dto, shared: true }); + await expect(service.getOne('t1', admin, created.id)).rejects.toBeInstanceOf(NotFoundException); + await expect(service.update('t1', admin, created.id, { name: 'x' })).rejects.toBeInstanceOf( NotFoundException, ); - await expect(service.remove('t1', created.id)).rejects.toBeInstanceOf(NotFoundException); + await expect(service.remove('t1', admin, created.id)).rejects.toBeInstanceOf(NotFoundException); + expect(prisma.customModule.update).not.toHaveBeenCalled(); + expect(prisma.customModule.delete).not.toHaveBeenCalled(); + }); +}); + +describe('CustomModulesService — aendern und loeschen', () => { + it('der Besitzer aendert und loescht seinen persoenlichen Eintrag', async () => { + const { prisma, service } = setup(); + const created: any = await service.create('t1', userA, dto); + const updated: any = await service.update('t1', userA, created.id, { name: 'Neu' }); + expect(updated.name).toBe('Neu'); + expect(updated.personal).toBe(true); + await expect(service.remove('t1', userA, created.id)).resolves.toEqual({ deleted: true }); + expect(prisma.rows.size).toBe(0); + }); + + it('ein anderer Benutzer kann den persoenlichen Eintrag weder aendern noch loeschen (404)', async () => { + const { prisma, service } = setup(); + const created: any = await service.create('t1', userA, dto); + await expect(service.update('t1', userB, created.id, { name: 'x' })).rejects.toBeInstanceOf( + NotFoundException, + ); + await expect(service.remove('t1', userB, created.id)).rejects.toBeInstanceOf(NotFoundException); expect(prisma.customModule.update).not.toHaveBeenCalled(); expect(prisma.customModule.delete).not.toHaveBeenCalled(); }); - it('update aendert nur gesetzte Felder', async () => { - const prisma = makeFakePrisma(); - const service = new CustomModulesService(prisma as any); - const created: any = await service.create('t1', dto); - await service.update('t1', created.id, { name: 'Neu' }); - expect(prisma.customModule.update.mock.calls[0][0].data).toEqual({ name: 'Neu' }); + it('auch ein Administrator kann den persoenlichen Eintrag eines Benutzers nicht aendern (404)', async () => { + const { prisma, service } = setup(); + const created: any = await service.create('t1', userA, dto); + await expect(service.update('t1', admin, created.id, { name: 'x' })).rejects.toBeInstanceOf( + NotFoundException, + ); + await expect(service.remove('t1', admin, created.id)).rejects.toBeInstanceOf(NotFoundException); + expect(prisma.rows.size).toBe(1); }); - it('remove loescht und liefert { deleted: true }', async () => { - const prisma = makeFakePrisma(); - const service = new CustomModulesService(prisma as any); - const created: any = await service.create('t1', dto); - await expect(service.remove('t1', created.id)).resolves.toEqual({ deleted: true }); + it('ein normaler Benutzer kann einen gemeinsamen Eintrag weder aendern noch loeschen (403)', async () => { + const { prisma, service } = setup(); + const created: any = await service.create('t1', admin, { ...dto, shared: true }); + await expect(service.update('t1', userA, created.id, { name: 'x' })).rejects.toBeInstanceOf( + ForbiddenException, + ); + await expect(service.remove('t1', userA, created.id)).rejects.toBeInstanceOf( + ForbiddenException, + ); + expect(prisma.customModule.update).not.toHaveBeenCalled(); + expect(prisma.customModule.delete).not.toHaveBeenCalled(); + }); + + it('ein Administrator aendert und loescht einen gemeinsamen Eintrag', async () => { + const { prisma, service } = setup(); + const created: any = await service.create('t1', admin, { ...dto, shared: true }); + const updated: any = await service.update('t1', admin, created.id, { name: 'Neu' }); + expect(updated.name).toBe('Neu'); + expect(updated.personal).toBe(false); + await expect(service.remove('t1', admin, created.id)).resolves.toEqual({ deleted: true }); expect(prisma.rows.size).toBe(0); }); - it('ruft forTenant je Methode mit (prisma, tenantId) auf', async () => { - const prisma = makeFakePrisma(); - const service = new CustomModulesService(prisma as any); - vi.mocked(forTenant).mockClear(); - const created: any = await service.create('t1', dto); - await service.list('t1'); - await service.getOne('t1', created.id); - await service.update('t1', created.id, { name: 'a' }); - await service.remove('t1', created.id); - expect(forTenant).toHaveBeenCalledTimes(5); - for (const call of vi.mocked(forTenant).mock.calls) { - expect(call).toEqual([prisma, 't1']); - } + it('update aendert nur gesetzte Felder und nie Besitz oder Gemeinsamkeit', async () => { + const { prisma, service } = setup(); + const created: any = await service.create('t1', userA, dto); + await service.update('t1', userA, created.id, { + name: 'Neu', + shared: true, + ownerUserId: 'ub', + } as any); + expect(prisma.customModule.update.mock.calls[0][0].data).toEqual({ name: 'Neu' }); + }); +}); + +describe('CustomModulesService — RLS-Bindung', () => { + it('bindet persoenliche Zugriffe mit Benutzer, gemeinsame Schreibzugriffe ohne', async () => { + const { prisma, service } = setup(); + vi.mocked(forTenant).mockClear(); + const shared: any = await service.create('t1', admin, { ...dto, shared: true }); + const mine: any = await service.create('t1', userA, dto); + await service.list('t1', userA); + await service.getOne('t1', userA, mine.id); + await service.update('t1', userA, mine.id, { name: 'a' }); + await service.update('t1', admin, shared.id, { name: 'b' }); + const calls = vi.mocked(forTenant).mock.calls; + // create shared: ohne Benutzer + expect(calls[0]).toEqual([prisma, 't1']); + // create personal + list + getOne + (update personal: Laden + Schreiben) + expect(calls[1]).toEqual([prisma, 't1', 'ua']); + expect(calls[2]).toEqual([prisma, 't1', 'ua']); + expect(calls[3]).toEqual([prisma, 't1', 'ua']); + // update shared als Admin: Laden mit Benutzer, Schreiben ohne + expect(calls[calls.length - 2]).toEqual([prisma, 't1', 'admin1']); + expect(calls[calls.length - 1]).toEqual([prisma, 't1']); }); }); diff --git a/apps/api/src/custom-modules/custom-modules.service.ts b/apps/api/src/custom-modules/custom-modules.service.ts index aa0669c..90ff399 100644 --- a/apps/api/src/custom-modules/custom-modules.service.ts +++ b/apps/api/src/custom-modules/custom-modules.service.ts @@ -1,4 +1,5 @@ -import { Injectable, NotFoundException } from '@nestjs/common'; +import { ForbiddenException, Injectable, NotFoundException } from '@nestjs/common'; +import { Role } from '@prisma/client'; import { PrismaService } from '../prisma/prisma.service'; import { forTenant } from '../prisma/prisma-tenant.extension'; import type { CreateCustomModuleDto, UpdateCustomModuleDto } from './dto/custom-module.dto'; @@ -9,34 +10,132 @@ const CUSTOM_MODULE_SELECT = { name: true, url: true, category: true, + ownerUserId: true, createdAt: true, updatedAt: true, }; +/** Der Aufrufer, wie ihn der Controller aus dem Anmelde-Token liest. */ +export interface CustomModuleCaller { + id: string; + role: Role; +} + +function isAdmin(caller: CustomModuleCaller): boolean { + return caller.role === Role.ADMIN || caller.role === Role.SUPER_ADMIN; +} + +/** Aus der Zeile die Antwort machen: `personal` statt der Besitzer-Kennung. */ +function toResponse(row: T) { + const { ownerUserId, ...rest } = row; + return { ...rest, personal: ownerUserId !== null }; +} + /** - * Eigene Module (quick-260929-9wc): vom Administrator angelegte - * Seitenleisten-Eintraege mit externer https-Adresse. `tenantId` kommt - * ausschliesslich als Argument (aus `req.tenantId`), nie aus dem DTO. Je - * Methode ein eigener `forTenant`-Klient; zusaetzlich pruefen - * getOne/update/remove `row.tenantId` — zweites Netz, solange der - * RLS-Schalter aus ist (Muster DashboardImage). Eine fremde oder unbekannte - * id ergibt immer `NotFoundException`, nie einen Hinweis auf die Existenz. + * Eigene Module (quick-260929-9wc, erweitert in quick-260929-dzu): Seitenleisten- + * Eintraege mit externer https-Adresse. Zwei Arten: + * + * - gemeinsam (`ownerUserId` null): vom Administrator angelegt, fuer alle + * Benutzer des Mandanten sichtbar; Schreiben nur fuer Administratoren. + * - persoenlich (`ownerUserId` = Benutzer): nur der Besitzer sieht, aendert und + * loescht ihn. Ein anderer Benutzer bekommt fuer die id immer 404 — nie einen + * Hinweis, dass es sie gibt. + * + * `tenantId` kommt ausschliesslich als Argument (aus `req.tenantId`), nie aus + * dem DTO. Je Methode ein eigener `forTenant`-Klient. + * + * RLS-BINDUNG (Muster SearchProvider, siehe Migration 20260929130000): Lesen + * und Schreiben PERSOENLICHER Eintraege laeuft mit dem Benutzer als drittem + * Argument (`forTenant(prisma, tenantId, user.id)`); die Regel laesst dann nur + * gemeinsame und eigene Zeilen zu. Schreiben GEMEINSAMER Eintraege laeuft + * bewusst OHNE Benutzer (`forTenant(prisma, tenantId)`), weil die Regel einem + * Benutzerkontext das Schreiben gemeinsamer Zeilen verwehrt — die + * Rollenpruefung (Administrator) sitzt vorher im Dienst. Zusaetzlich pruefen + * alle Methoden `row.tenantId` und `row.ownerUserId` in der Anwendung, solange + * der RLS-Schalter aus ist. */ @Injectable() export class CustomModulesService { constructor(private readonly prisma: PrismaService) {} - async list(tenantId: string) { - const tenantPrisma = forTenant(this.prisma, tenantId); - return tenantPrisma.customModule.findMany({ - where: { tenantId }, + /** Gemeinsame Eintraege plus die eigenen des Aufrufers. */ + async list(tenantId: string, caller: CustomModuleCaller) { + const tenantPrisma = forTenant(this.prisma, tenantId, caller.id); + const rows = await tenantPrisma.customModule.findMany({ + where: { tenantId, OR: [{ ownerUserId: null }, { ownerUserId: caller.id }] }, orderBy: { name: 'asc' }, select: CUSTOM_MODULE_SELECT, }); + return rows.map(toResponse); } - async getOne(tenantId: string, id: string) { - const tenantPrisma = forTenant(this.prisma, tenantId); + async getOne(tenantId: string, caller: CustomModuleCaller, id: string) { + const tenantPrisma = forTenant(this.prisma, tenantId, caller.id); + const row = await this.loadVisible(tenantPrisma, tenantId, caller, id); + const { tenantId: _omit, ...result } = row; + return toResponse(result); + } + + async create(tenantId: string, caller: CustomModuleCaller, dto: CreateCustomModuleDto) { + const shared = dto.shared === true; + if (shared && !isAdmin(caller)) { + throw new ForbiddenException('Gemeinsame Einträge dürfen nur Administratoren anlegen'); + } + const data = { + tenantId, + name: dto.name, + url: dto.url, + category: dto.category, + ownerUserId: shared ? null : caller.id, + }; + if (shared) { + // Gemeinsam: ohne Benutzerkontext (die Regel verwehrt ihn dort). + const tenantPrisma = forTenant(this.prisma, tenantId); + const row = await tenantPrisma.customModule.create({ data, select: CUSTOM_MODULE_SELECT }); + return toResponse(row); + } + const tenantPrisma = forTenant(this.prisma, tenantId, caller.id); + const row = await tenantPrisma.customModule.create({ data, select: CUSTOM_MODULE_SELECT }); + return toResponse(row); + } + + async update( + tenantId: string, + caller: CustomModuleCaller, + id: string, + dto: UpdateCustomModuleDto, + ) { + const tenantPrisma = await this.writableClient(tenantId, caller, id); + const data: { name?: string; url?: string; category?: string } = {}; + if (dto.name !== undefined) data.name = dto.name; + if (dto.url !== undefined) data.url = dto.url; + if (dto.category !== undefined) data.category = dto.category; + // Besitz und Gemeinsamkeit stehen nie in `data` — sie aendern sich nicht. + const row = await tenantPrisma.customModule.update({ + where: { id }, + data, + select: CUSTOM_MODULE_SELECT, + }); + return toResponse(row); + } + + async remove(tenantId: string, caller: CustomModuleCaller, id: string) { + const tenantPrisma = await this.writableClient(tenantId, caller, id); + await tenantPrisma.customModule.delete({ where: { id } }); + return { deleted: true }; + } + + /** + * Zeile laden, die der Aufrufer sehen darf: gleicher Mandant UND (gemeinsam + * ODER eigene). Alles andere — unbekannt, fremder Mandant, fremder + * persoenlicher Eintrag — ist ununterscheidbar 404. + */ + private async loadVisible( + tenantPrisma: ReturnType, + tenantId: string, + caller: CustomModuleCaller, + id: string, + ) { const row = await tenantPrisma.customModule.findUnique({ where: { id }, select: { ...CUSTOM_MODULE_SELECT, tenantId: true }, @@ -44,42 +143,28 @@ export class CustomModulesService { if (!row || row.tenantId !== tenantId) { throw new NotFoundException('Eigenes Modul nicht gefunden'); } - const { tenantId: _omit, ...result } = row; - return result; - } - - async create(tenantId: string, dto: CreateCustomModuleDto) { - const tenantPrisma = forTenant(this.prisma, tenantId); - return tenantPrisma.customModule.create({ - data: { tenantId, name: dto.name, url: dto.url, category: dto.category }, - select: CUSTOM_MODULE_SELECT, - }); - } - - async update(tenantId: string, id: string, dto: UpdateCustomModuleDto) { - const tenantPrisma = forTenant(this.prisma, tenantId); - const existing = await tenantPrisma.customModule.findUnique({ where: { id } }); - if (!existing || existing.tenantId !== tenantId) { + if (row.ownerUserId !== null && row.ownerUserId !== caller.id) { throw new NotFoundException('Eigenes Modul nicht gefunden'); } - const data: { name?: string; url?: string; category?: string } = {}; - if (dto.name !== undefined) data.name = dto.name; - if (dto.url !== undefined) data.url = dto.url; - if (dto.category !== undefined) data.category = dto.category; - return tenantPrisma.customModule.update({ - where: { id }, - data, - select: CUSTOM_MODULE_SELECT, - }); + return row; } - async remove(tenantId: string, id: string) { - const tenantPrisma = forTenant(this.prisma, tenantId); - const existing = await tenantPrisma.customModule.findUnique({ where: { id } }); - if (!existing || existing.tenantId !== tenantId) { - throw new NotFoundException('Eigenes Modul nicht gefunden'); + /** + * Klient fuer Aendern/Loeschen: persoenlicher Eintrag -> mit Benutzer (nur der + * Besitzer kommt bis hierher); gemeinsamer Eintrag -> nur Administrator (403 + * sonst, der Eintrag ist fuer alle sichtbar, sein Bestehen ist kein + * Geheimnis), dann ohne Benutzerkontext. + */ + private async writableClient(tenantId: string, caller: CustomModuleCaller, id: string) { + const userClient = forTenant(this.prisma, tenantId, caller.id); + const row = await this.loadVisible(userClient, tenantId, caller, id); + if (row.ownerUserId === caller.id) { + return userClient; } - await tenantPrisma.customModule.delete({ where: { id } }); - return { deleted: true }; + if (!isAdmin(caller)) { + throw new ForbiddenException('Gemeinsame Einträge dürfen nur Administratoren ändern'); + } + const tenantPrisma = forTenant(this.prisma, tenantId); + return tenantPrisma; } } diff --git a/apps/api/src/custom-modules/dto/custom-module.dto.ts b/apps/api/src/custom-modules/dto/custom-module.dto.ts index 7f1b754..a5a9b73 100644 --- a/apps/api/src/custom-modules/dto/custom-module.dto.ts +++ b/apps/api/src/custom-modules/dto/custom-module.dto.ts @@ -1,9 +1,11 @@ -import { PartialType } from '@nestjs/mapped-types'; +import { OmitType, PartialType } from '@nestjs/mapped-types'; import { MODULE_CATEGORIES } from '@tessera/shared'; import { Transform } from 'class-transformer'; import { + IsBoolean, IsIn, IsNotEmpty, + IsOptional, IsString, MaxLength, Validate, @@ -60,7 +62,23 @@ export class CreateCustomModuleDto { @IsIn([...MODULE_CATEGORIES]) category!: (typeof MODULE_CATEGORIES)[number]; + + /** + * quick-260929-dzu: `true` legt einen gemeinsamen Eintrag fuer alle Benutzer + * an (nur Administratoren, sonst 403 im Dienst). Fehlt das Feld oder ist es + * `false`, ist der Eintrag persoenlich und gehoert dem Aufrufer. + */ + @IsOptional() + @IsBoolean() + shared?: boolean; } -/** Teil-Update: jedes gesetzte Feld wird genauso geprueft wie beim Anlegen. */ -export class UpdateCustomModuleDto extends PartialType(CreateCustomModuleDto) {} +/** + * Teil-Update: jedes gesetzte Feld wird genauso geprueft wie beim Anlegen. + * `shared` ist ausgenommen — ob ein Eintrag gemeinsam oder persoenlich ist, + * aendert sich nach dem Anlegen nicht (die globale Pipe verwirft das Feld + * dank `whitelist: true`). + */ +export class UpdateCustomModuleDto extends PartialType( + OmitType(CreateCustomModuleDto, ['shared'] as const), +) {} diff --git a/docs/mandantentrennung-zugriffsklassifikation.md b/docs/mandantentrennung-zugriffsklassifikation.md index eaeb799..f84fa7a 100644 --- a/docs/mandantentrennung-zugriffsklassifikation.md +++ b/docs/mandantentrennung-zugriffsklassifikation.md @@ -176,8 +176,8 @@ Spalten sind mit der Schleife aus dem Gate von 260914-eym nachgerechnet | bug-reports | 0 | 1 | 0 | neu (260914-m97), ein gebundener Zugriff | | settings | 0 | 4 | 0 | **Nachgemessen 260921-pi9: 4 gebundene Rohtreffer** (die Tabelle nannte 3; der vierte `smtpConfig`-Zugriff kam mit 260914-m97/`bugReportRecipient` hinzu, ohne dass die Zeile nachgezogen wurde). **war 4/0** — 260911-gwh (Aufgabe 2) hat `getSmtpConfig`, `saveSmtpConfig`, `getDecryptedSmtpConfig` auf `forTenant()` umgestellt (3 gebundene `smtpConfig`-Rohtreffer). Der eine verbleibende ungebundene Rohtreffer war der umbenannte Planer-Startpfad `loadAnySmtpConfigForStartupTransport()` (Befund D, WINDOWS #30). **260914-eym:** GELÖSCHT — `MailService` baut je Versand einen Transport über `getDecryptedSmtpConfig(tenantId)` (1→0 ungebunden, 0 System, kein Systemkontext nötig); Befund K (`tenders`/`dkv`/`mail` hängen an `getDecryptedSmtpConfig`) ist damit erfüllt — WINDOWS #30 geschlossen | | proxmox | 0 | 11 | 1 | **quick-260923-dhh (Aufgabe 5, Endstand):** 7→11 gebunden — `updateServer` (`proxmoxServer.findUnique` UND `.update`) und `deleteServer` (`proxmoxServer.findUnique` UND `.delete`) bringen vier weitere gebundene Rohtreffer, je ein Klient je Methode. Nachgemessen mit der Gate-Schleife (`grep -c` ueber `tenantPrisma\.\(proxmoxServer\|proxmoxServerStatus\)\.` in `proxmox.service.ts`: 10 fuer `proxmoxServer`, 1 fuer `proxmoxServerStatus`). Vorher: **quick-260923-dhh (Aufgabe 4):** 4→7 gebunden, 0→1 System — `proxmox.service.ts` bringt drei weitere gebundene Rohtreffer (`pollServer` mit `include: { status: true }` bleibt EIN Klient, `testConnection`, `listActiveServerIdsForTenant`, `loadActiveServersForTenantScheduling` — vier neue Methoden, aber `pollServer`s zweiter Zugriff war schon gezaehlt, macht drei zusaetzliche) und einen System-Rohtreffer (`loadActiveServersForScheduler()`, der einzige `forSystem()`-Aufruf des Moduls, Erlaubnisliste in `rls-access-inventory.spec.ts`). Vorher: **quick-260923-dhh (Aufgabe 1):** neu, vier gebundene Rohtreffer: `createServer` (`proxmoxServer.create`), `listWithStatus` (`proxmoxServer.findMany`), `pollServer` (`proxmoxServer.findUnique` UND `proxmoxServerStatus.upsert`, DERSELBE Klient in derselben Methode) | -| custom-modules | 0 | 7 | 0 | **quick-260929-9wc:** neu, sieben gebundene Rohtreffer in `custom-modules.service.ts` (`list` 1, `getOne` 1, `create` 1, `update` 2, `remove` 2), nachgemessen mit der Gate-Schleife: 0/7/0. Kein ungebundener Zugriff, kein Systemkontext. | -| **Summe** | **61** | **224** | **6** | **Nachgemessen quick-260929-9wc:** mit der Gate-Schleife (`for d in apps/api/src/*/`, nur .ts ohne spec), nicht abgeschrieben: 61/224/6. Gegenueber der bisherigen Zeile (61/216/6): Gebunden +8 = `user` +1 (Drift aus quick-260928-ujj, siehe dortige Zeile; gemessen war schon vorher 61/217/6) und `custom-modules` +7 (neu, siehe dortige Zeile), Ungebunden/System unveraendert. Vorher: **quick-260925-bow:** nachgerechnet mit der Gate-Schleife (`for d in apps/api/src/*/`), nicht abgeschrieben: 61/216/6. Gegenüber der bisherigen Zeile (61/213/6): Gebunden +3 = `user` +3 (die zwei Selbstbedienungswege des „Was ist neu“-Fensters in `user.controller.ts`, siehe dortige Zeile), Ungebunden/System unverändert. Vorher: **quick-260924-m4n:** nachgerechnet mit der Gate-Schleife (`for d in apps/api/src/*/`), nicht abgeschrieben: 61/213/6. Gegenüber der bisherigen Zeile (61/208/7): Gebunden +5 = `favorites` +4 (Drift aus quick-260923-lrr nachgeholt) und `dashboard` +1 (Drift +3 nachgeholt, diese Änderung −2; siehe dortige Zeilen), System −1 (`dashboard`, Bootstrap-Umzug der Bilderrahmen-Bilder entfernt). Vorher: **quick-260923-dhh (Aufgabe 5, Endstand):** Gebunden 204→208 (`proxmox` +4, siehe dortige Zeile), Ungebunden/System unverändert — nachgerechnet mit derselben Gate-Schleife, nicht abgeschrieben. Vorher: **quick-260923-dhh (Aufgabe 4):** Gebunden 201→204 (`proxmox` +3, siehe dortige Zeile), System 6→7 (`proxmox` +1) — nachgerechnet mit derselben Gate-Schleife, nicht abgeschrieben. Vorher: **quick-260923-dhh (Aufgabe 1):** Gebunden 197→201 (`proxmox` neu, +4, siehe dortige Zeile), Ungebunden/System unverändert. Vorher: **quick-260923-ad9 (Task 5, Endstand nach Task 2):** Gebunden 193→197 (`dashboard` +4, siehe dortige Zeile), Ungebunden/System unverändert — nachgerechnet mit derselben Gate-Schleife, nicht abgeschrieben. Vorher: **quick-260923-ad9 (Task 1):** Gebunden 190→193 (`dashboard` +3, siehe dortige Zeile), Ungebunden/System unverändert — nachgerechnet mit derselben Gate-Schleife, nicht abgeschrieben. **260922-hk4:** Gebunden 187→190, System 5→6 (beides `dashboard`, siehe dortige Zeile), Ungebunden unverändert — nachgerechnet mit derselben Gate-Schleife, nicht abgeschrieben. **260921-pi9:** Gebunden 179→187, nachgerechnet mit der Gate-Schleife: +6 in `dashboard` (Bilderrahmen), +1 in `settings` (Zeile war seit 260914-m97 um eins zu niedrig), +1 fuer `bug-reports` (Zeile seit 260914-m97 vorhanden, in der Summe aber nie mitgezaehlt) — die Summe stimmt damit wieder mit den Bereichszeilen ueberein. **260914-eym:** Ungebunden 68→61 (`tenders` −2, `ldap` −3, `dkv` −1, `settings` −1), Gebunden 178→179 (`ldap` +1), System 5 (`dkv` 1, `ldap` 2, `tenders` 2) — nachgerechnet mit der Gate-Schleife, nicht abgeschrieben. Vorgeschichte: Ungebunden: war 118 nach 260910-das, dann 108 nach 260910-exd (module-registry 17→7), dann 107 nach 260910-jab (`tenders` 36→35, `listForUser` gebunden), dann 95 nach 260910-krx (`dashboard` 13→1), dann 83 nach 260911-cwh (`calendar` 12→0), unverändert nach 260911-e2s (`tenant` bleibt bei 8 ungebundenen Rohtreffern), dann 78 nach 260911-fh9 (`auth` 8→3), jetzt 68 nach 260911-gwh (`favorites` 7→0, `settings` 4→1). Gebunden: war 124, dann 134 nach 260910-exd (zusätzlich 10 in `module-registry`), dann 135 nach 260910-jab (zusätzlich 1 in `tenders`), dann 147 nach 260910-krx (zusätzlich 12 in `dashboard`), dann 159 nach 260911-cwh (zusätzlich 12 in `calendar`), dann 162 nach 260911-e2s (zusätzlich 3 in `tenant`), dann 167 nach 260911-fh9 (zusätzlich 5 in `auth`), jetzt 178 nach 260911-gwh (zusätzlich 8 in `favorites`, 3 in `settings`). Dies ist der ENDSTAND der Etappe 2: jeder verbleibende ungebundene Rohtreffer ist einer der in diesem Dokument benannten, bewusst ungebundenen Fälle. Diese Übersicht ist eine Buchführungshilfe; **autoritativ ist die Fundstellentabelle unten**, die `rls-access-inventory.spec.ts` bei jedem Lauf gegen den Quelltext prüft | +| custom-modules | 0 | 6 | 0 | **Nachgemessen quick-260929-dzu:** 0/6/0 — persönliche Einträge je Benutzer: `create` trägt jetzt zwei Klienten in getrennten Zweigen (gemeinsam ohne Benutzer, persönlich mit Benutzer, je ein `tenantPrisma.customModule.create`), die gemeinsame Ladefunktion `loadVisible` trägt das einzige `findUnique` für `getOne`/`update`/`remove` (vorher je Methode eines): `list` 1, `create` 2, `loadVisible` 1, `update` 1, `remove` 1. Das Ergebnis ist ein Treffer weniger als bei quick-260929-9wc, obwohl der Zugriff strenger geworden ist. Vorher: **quick-260929-9wc:** neu, sieben gebundene Rohtreffer in `custom-modules.service.ts` (`list` 1, `getOne` 1, `create` 1, `update` 2, `remove` 2), nachgemessen mit der Gate-Schleife: 0/7/0. Kein ungebundener Zugriff, kein Systemkontext. | +| **Summe** | **61** | **223** | **6** | **Nachgemessen quick-260929-dzu:** mit der Gate-Schleife (`for d in apps/api/src/*/`, nur .ts ohne spec), nicht abgeschrieben: 61/223/6. Gegenüber der bisherigen Zeile (61/224/6): Gebunden −1 = `custom-modules` −1 (7→6, siehe dortige Zeile), Ungebunden/System unverändert. Vorher: **Nachgemessen quick-260929-9wc:** mit der Gate-Schleife (`for d in apps/api/src/*/`, nur .ts ohne spec), nicht abgeschrieben: 61/224/6. Gegenueber der bisherigen Zeile (61/216/6): Gebunden +8 = `user` +1 (Drift aus quick-260928-ujj, siehe dortige Zeile; gemessen war schon vorher 61/217/6) und `custom-modules` +7 (neu, siehe dortige Zeile), Ungebunden/System unveraendert. Vorher: **quick-260925-bow:** nachgerechnet mit der Gate-Schleife (`for d in apps/api/src/*/`), nicht abgeschrieben: 61/216/6. Gegenüber der bisherigen Zeile (61/213/6): Gebunden +3 = `user` +3 (die zwei Selbstbedienungswege des „Was ist neu“-Fensters in `user.controller.ts`, siehe dortige Zeile), Ungebunden/System unverändert. Vorher: **quick-260924-m4n:** nachgerechnet mit der Gate-Schleife (`for d in apps/api/src/*/`), nicht abgeschrieben: 61/213/6. Gegenüber der bisherigen Zeile (61/208/7): Gebunden +5 = `favorites` +4 (Drift aus quick-260923-lrr nachgeholt) und `dashboard` +1 (Drift +3 nachgeholt, diese Änderung −2; siehe dortige Zeilen), System −1 (`dashboard`, Bootstrap-Umzug der Bilderrahmen-Bilder entfernt). Vorher: **quick-260923-dhh (Aufgabe 5, Endstand):** Gebunden 204→208 (`proxmox` +4, siehe dortige Zeile), Ungebunden/System unverändert — nachgerechnet mit derselben Gate-Schleife, nicht abgeschrieben. Vorher: **quick-260923-dhh (Aufgabe 4):** Gebunden 201→204 (`proxmox` +3, siehe dortige Zeile), System 6→7 (`proxmox` +1) — nachgerechnet mit derselben Gate-Schleife, nicht abgeschrieben. Vorher: **quick-260923-dhh (Aufgabe 1):** Gebunden 197→201 (`proxmox` neu, +4, siehe dortige Zeile), Ungebunden/System unverändert. Vorher: **quick-260923-ad9 (Task 5, Endstand nach Task 2):** Gebunden 193→197 (`dashboard` +4, siehe dortige Zeile), Ungebunden/System unverändert — nachgerechnet mit derselben Gate-Schleife, nicht abgeschrieben. Vorher: **quick-260923-ad9 (Task 1):** Gebunden 190→193 (`dashboard` +3, siehe dortige Zeile), Ungebunden/System unverändert — nachgerechnet mit derselben Gate-Schleife, nicht abgeschrieben. **260922-hk4:** Gebunden 187→190, System 5→6 (beides `dashboard`, siehe dortige Zeile), Ungebunden unverändert — nachgerechnet mit derselben Gate-Schleife, nicht abgeschrieben. **260921-pi9:** Gebunden 179→187, nachgerechnet mit der Gate-Schleife: +6 in `dashboard` (Bilderrahmen), +1 in `settings` (Zeile war seit 260914-m97 um eins zu niedrig), +1 fuer `bug-reports` (Zeile seit 260914-m97 vorhanden, in der Summe aber nie mitgezaehlt) — die Summe stimmt damit wieder mit den Bereichszeilen ueberein. **260914-eym:** Ungebunden 68→61 (`tenders` −2, `ldap` −3, `dkv` −1, `settings` −1), Gebunden 178→179 (`ldap` +1), System 5 (`dkv` 1, `ldap` 2, `tenders` 2) — nachgerechnet mit der Gate-Schleife, nicht abgeschrieben. Vorgeschichte: Ungebunden: war 118 nach 260910-das, dann 108 nach 260910-exd (module-registry 17→7), dann 107 nach 260910-jab (`tenders` 36→35, `listForUser` gebunden), dann 95 nach 260910-krx (`dashboard` 13→1), dann 83 nach 260911-cwh (`calendar` 12→0), unverändert nach 260911-e2s (`tenant` bleibt bei 8 ungebundenen Rohtreffern), dann 78 nach 260911-fh9 (`auth` 8→3), jetzt 68 nach 260911-gwh (`favorites` 7→0, `settings` 4→1). Gebunden: war 124, dann 134 nach 260910-exd (zusätzlich 10 in `module-registry`), dann 135 nach 260910-jab (zusätzlich 1 in `tenders`), dann 147 nach 260910-krx (zusätzlich 12 in `dashboard`), dann 159 nach 260911-cwh (zusätzlich 12 in `calendar`), dann 162 nach 260911-e2s (zusätzlich 3 in `tenant`), dann 167 nach 260911-fh9 (zusätzlich 5 in `auth`), jetzt 178 nach 260911-gwh (zusätzlich 8 in `favorites`, 3 in `settings`). Dies ist der ENDSTAND der Etappe 2: jeder verbleibende ungebundene Rohtreffer ist einer der in diesem Dokument benannten, bewusst ungebundenen Fälle. Diese Übersicht ist eine Buchführungshilfe; **autoritativ ist die Fundstellentabelle unten**, die `rls-access-inventory.spec.ts` bei jedem Lauf gegen den Quelltext prüft | ## Klassen-Verteilung (nach (Datei, Modell)-Fundstellen, 79 Paare) @@ -362,6 +362,10 @@ Tabelle hinzugekommen, ohne sie fortzuschreiben. Jetzt +1 `muss-mandantengebunde `muss-mandantengebunden`, 21 `keine-mandantengebundene-tabelle`, 14 `beides`, 2 `bewusst-uebergreifend`. +quick-260929-dzu: keine neue (Datei, Modell)-Zeile, Verteilung unverändert (79 Paare); geändert +haben sich nur die Zeile `custom-modules.service.ts`/`customModule` (Benutzerdimension) und die +Bereichs-/Summenzeile (Gebunden 224→223, nachgemessen mit der Gate-Schleife). + ## Der Hintergrunddienst als Falle — sechs Fälle Ein Planer, der über alle Mandanten iteriert, liest zu Recht übergreifend — @@ -774,7 +778,7 @@ werden. | apps/api/src/user/user.service.ts | user | beides | gemischt | Klassenkorrektur (260910-das, Aufgabe 3): wechselt von `muss-mandantengebunden` auf `beides` wegen der einen bewusst ungebundenen Suche — wortgleich derselbe Praezedenzfall wie `ldap.service.ts`/`user` in 260909-ipc (`resolveEmailForWrite`). `findById`/`create`/`update`/`deactivate`/`delete` sowie die beiden neuen Plattform-Administratorsicht-Methoden laufen ueber `forTenant()`; `create`/`update` uebersetzen eine plattformweite Eindeutigkeitsverletzung (P2002) in eine deutsche Konfliktmeldung ohne Halter/Mandant zu nennen. `findByUsername` bleibt bewusst UNGEBUNDEN: der Anmeldeweg laeuft seit Etappe 1 ueber die drei SECURITY-DEFINER-Funktionen und hat diese Methode nicht mehr als Aufrufer (260910-das, Aufgabe 1, Teil 3: genau ein Treffer, die eigene Definition); eine gebundene Suche saehe einen fremden Halter des plattformweit eindeutigen `username` nicht und meldete faelschlich "frei". | | apps/api/src/proxmox/proxmox.service.ts | proxmoxServer | muss-mandantengebunden | system-gebunden | **quick-260923-dhh, Aufgabe 4:** Stand von `gebunden` auf `system-gebunden` — NICHT weil ein Anfrageweg aufgeweicht wurde, sondern weil EIN Startpfad dazugekommen ist: `loadActiveServersForScheduler()` liest beim Start des Planers `const systemPrisma = forSystem(this.prisma);` (ein Aufruf, Erlaubnisliste in `rls-access-inventory.spec.ts`; Leserecht ueber `system_read_policy … FOR SELECT` auf "ProxmoxServer", Migration 20260923140000) — der Planer muss die aktiven Server ALLER Mandanten sehen, um je Mandant einen Cron-Auftrag zu registrieren (Muster `DkvSchedulerService`). GESCHRIEBEN wird auch dort nur je Zeile gebunden. Sechs mandantengebundene Zugriffe blieben nach Aufgabe 4 bestehen: `createServer` (`proxmoxServer.create`), `listWithStatus` (`findMany`), `pollServer` (`findUnique`, mit `include: { status: true }` fuer die Zehn-Sekunden-Sperre), `testConnection` (`findUnique`), `listActiveServerIdsForTenant` (`findMany`), `loadActiveServersForTenantScheduling` (`findMany` auf `proxmoxServer`, `select: { pollIntervalMin: true }`). **Aufgabe 5** ergaenzt vier weitere: `updateServer` (`findUnique` UND `update`) und `deleteServer` (`findUnique` UND `delete`), je ein Klient je Methode — macht zehn mandantengebundene `proxmoxServer`-Rohtreffer insgesamt, plus der eine System-Rohtreffer aus Aufgabe 4. Vorher (Aufgabe 1): vom Administrator eingetragene Proxmox-Server (PVE/PBS/PMG), `tenantId`-Spalte vorhanden, Regel `tenant_isolation_policy` OHNE Benutzerdimension (Migration 20260923140000, Form aus `DkvModuleConfig`) — Verwaltungsdaten des Mandanten, nicht persoenliche Daten eines Benutzers. `listWithStatus` waehlt die beiden Geheimnisfelder (`encryptedTokenSecret`/`encryptedPassword`) per `select` gar nicht erst aus (T-DHH-01). | | apps/api/src/proxmox/proxmox.service.ts | proxmoxServerStatus | muss-mandantengebunden | gebunden | quick-260923-dhh, Aufgabe 1/4 — Zwischenlager je Server (D-05), `tenantId`-Spalte vorhanden, Regel `tenant_isolation_policy` OHNE Benutzerdimension (Migration 20260923140000, dieselbe Form wie `proxmoxServer`). `pollServer` schreibt ueber `tenantPrisma.proxmoxServerStatus.upsert()`, DENSELBEN Klienten wie das Lesen des Servers in derselben Methode; dieselbe Methode liest zusaetzlich `include: { status: true }` fuer die Zehn-Sekunden-Sperre (Aufgabe 4, T-DHH-06) — ebenfalls ueber den gebundenen Klienten. Bewusst KEINE `system_read_policy` auf dieser Tabelle (anders als `proxmoxServer`) — der Planer-Startpfad liest nur die Serverzeilen, das Zwischenlager wird ausschliesslich je Mandant gebunden geschrieben, ein Systemlesezugriff hat keinen Aufrufer. | -| apps/api/src/custom-modules/custom-modules.service.ts | customModule | muss-mandantengebunden | gebunden | **quick-260929-9wc:** neu — vom Administrator angelegte Seitenleisten-Eintraege („Eigene Module“, Name, https-Adresse, Kategorie), fuer alle Benutzer des Mandanten sichtbar. `tenantId`-Spalte vorhanden, Regel `tenant_isolation_policy` OHNE Benutzerdimension (Migration 20260929120000, Form aus `ProxmoxServer`) — Verwaltungsdaten des Mandanten, nicht persoenliche Daten eines Benutzers. Bewusst KEINE `system_read_policy`: es gibt keinen Hintergrunddienst, der eigene Module ueber alle Mandanten liest. Sieben mandantengebundene Rohtreffer, je Methode ein eigener Klient (`const tenantPrisma = forTenant(this.prisma, tenantId)`): `list` (`findMany` mit `where: { tenantId }`), `getOne` (`findUnique`), `create`, `update` (`findUnique` UND `update`), `remove` (`findUnique` UND `delete`). `getOne`/`update`/`remove` pruefen zusaetzlich `row.tenantId !== tenantId` und antworten mit 404 — zweites Netz, solange der RLS-Schalter aus ist (Muster `dashboardImage`). | +| apps/api/src/custom-modules/custom-modules.service.ts | customModule | muss-mandantengebunden | gebunden | **quick-260929-9wc:** neu — vom Administrator angelegte Seitenleisten-Eintraege („Eigene Module“, Name, https-Adresse, Kategorie), fuer alle Benutzer des Mandanten sichtbar. `tenantId`-Spalte vorhanden, Regel `tenant_isolation_policy` OHNE Benutzerdimension (Migration 20260929120000, Form aus `ProxmoxServer`) — Verwaltungsdaten des Mandanten, nicht persoenliche Daten eines Benutzers. Bewusst KEINE `system_read_policy`: es gibt keinen Hintergrunddienst, der eigene Module ueber alle Mandanten liest. Sieben mandantengebundene Rohtreffer, je Methode ein eigener Klient (`const tenantPrisma = forTenant(this.prisma, tenantId)`): `list` (`findMany` mit `where: { tenantId }`), `getOne` (`findUnique`), `create`, `update` (`findUnique` UND `update`), `remove` (`findUnique` UND `delete`). `getOne`/`update`/`remove` pruefen zusaetzlich `row.tenantId !== tenantId` und antworten mit 404 — zweites Netz, solange der RLS-Schalter aus ist (Muster `dashboardImage`). **quick-260929-dzu — persönliche Einträge:** neue Spalte `ownerUserId` (NULL = gemeinsam, gesetzt = persönlich, nur für den Besitzer sichtbar). Klasse und Stand unverändert (`muss-mandantengebunden`, `gebunden`); der Zeilenschutz bekommt die Benutzerdimension nach dem Muster `SearchProvider` (Migration 20260929130000): vier nach Befehl getrennte Regeln — Lesen: Mandant UND (kein Benutzer gesetzt ODER `ownerUserId` NULL ODER eigene Zeile), Schreiben (INSERT/UPDATE/DELETE): Mandant UND (kein Benutzer gesetzt ODER eigene Zeile). Persönliche Zugriffe binden mit Benutzer (`forTenant(prisma, tenantId, user.id)`); das Schreiben GEMEINSAMER Einträge bindet bewusst OHNE Benutzer, weil die Regel einem Benutzerkontext das Schreiben gemeinsamer Zeilen verwehrt — davor prüft der Dienst die Rolle (nur Administrator, sonst 403). Fremde persönliche Einträge sind für jeden anderen Benutzer, auch Administratoren, ununterscheidbar 404. Sechs mandantengebundene Rohtreffer (siehe Bereichszeile). | ## Was diese Etappe NICHT entscheidet