tessera-ctl/apps/api/scripts/rls-scratch-check.mjs

#!/usr/bin/env node
// WINDOWS #20 (260909-eor) — richtet sich eine eigene Wegwerf-Datenbank ein
// und misst dort live, ob das reparierte forTenant()-Muster (Aufgabe 1)
// tatsaechlich das tut, was es behauptet. Aufgabe 2 erweitert dieses
// Werkzeug um einen zweiten Abschnitt fuer die auth_lookup_*-Funktionen.
//
// Ruehrt die Datenbank "tessera" NICHT an (T-EOR-07): der Name der
// Wegwerf-Datenbank ist fest im Werkzeug verdrahtet, nicht ueber eine
// Umgebungsvariable steuerbar, damit ein Tippfehler nicht in der echten
// Datenbank landet. Verbindungsangaben kommen ausschliesslich ueber
// TESSERA_SCRATCH_ADMIN_URL (Verbindung zu einer Wartungsdatenbank wie
// "postgres" mit Rechten, um eine neue Datenbank/Rolle anzulegen und wieder
// abzuraeumen). Ohne diese Variable bricht das Werkzeug mit einer Anleitung
// ab, statt eine Vorgabe zu raten.
//
// Nutzt ausschliesslich @prisma/client (bereits Abhaengigkeit der API) —
// kein neues Paket. Fuer DDL (CREATE DATABASE/ROLE mit festen, im Werkzeug
// hartkodierten Namen) ist Interpolation unvermeidlich, da PostgreSQL
// Identifier nicht parametrisieren kann; es fliesst dabei nirgends
// Nutzereingabe ein.
//
// Dupliziert bewusst das forTenant()-Verbindungsmuster statt die
// TypeScript-Quelle unter apps/api/src zu importieren — dasselbe Vorgehen
// wie im bestehenden apps/api/scripts/rls-preflight.mjs, weil ein reines
// Node-Skript ohne Build-Schritt kein .ts importieren kann.
//
// Meldet je Pruefung eine Zeile und beendet sich mit Rueckgabewert 1, sobald
// eine Pruefung scheitert. Gibt kein Kennwort und keine vollstaendige
// Verbindungszeichenkette aus.

import { PrismaClient } from '@prisma/client';
import { execFileSync } from 'node:child_process';
import { mkdtempSync, readdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
import { tmpdir } from 'node:os';
import { dirname, join } from 'node:path';
import { fileURLToPath } from 'node:url';

const __dirname = dirname(fileURLToPath(import.meta.url));
const ADMIN_ENV_VAR = 'TESSERA_SCRATCH_ADMIN_URL';
const SCRATCH_DB_NAME = 'tessera_rls_scratch';
const SCRATCH_ROLE_NAME = 'tessera_rls_scratch_role';
const SCRATCH_ROLE_PASSWORD = 'scratch_only_local_never_reused';
const MIGRATIONS_DIR = join(__dirname, '../prisma/migrations');
const PRISMA_BIN = join(__dirname, '../node_modules/.bin/prisma');

/**
 * Fuehrt ein mehrteiliges SQL-Skript (mehrere Anweisungen, DO $$ ... $$
 * -Bloecke) als EIN Kommando aus. `prisma.$executeRawUnsafe` nutzt das
 * erweiterte Protokoll und erlaubt pro Aufruf nur eine einzelne Anweisung —
 * `prisma db execute --file` sendet das gesamte Skript dagegen als ein
 * Kommando (einfaches Protokoll) und ist genau dafuer vorgesehen, ganze
 * Migrationsdateien auszufuehren.
 */
function executeSqlScript(databaseUrl, sql) {
  const dir = mkdtempSync(join(tmpdir(), 'rls-scratch-check-'));
  const file = join(dir, 'script.sql');
  writeFileSync(file, sql, 'utf-8');
  try {
    execFileSync(PRISMA_BIN, ['db', 'execute', '--file', file, '--url', databaseUrl], {
      stdio: 'pipe',
    });
  } finally {
    rmSync(dir, { recursive: true, force: true });
  }
}

function fail(message) {
  console.error(`FEHLER: ${message}`);
  process.exit(1);
}

function parseAdminUrl() {
  const raw = process.env[ADMIN_ENV_VAR];
  if (!raw) {
    fail(
      `${ADMIN_ENV_VAR} ist nicht gesetzt. Beispiel: ` +
        `${ADMIN_ENV_VAR}="postgresql://tessera:tessera_dev@172.19.0.2:5432/postgres" ` +
        `node apps/api/scripts/rls-scratch-check.mjs`,
    );
  }
  return raw;
}

function urlForDatabase(adminUrl, dbName) {
  const url = new URL(adminUrl);
  url.pathname = `/${dbName}`;
  return url;
}

async function withAdminPrisma(adminUrl, fn) {
  const prisma = new PrismaClient({ datasourceUrl: adminUrl });
  try {
    return await fn(prisma);
  } finally {
    await prisma.$disconnect();
  }
}

async function setupScratchDatabase(adminUrl) {
  await withAdminPrisma(adminUrl, async (admin) => {
    await admin.$executeRawUnsafe(
      `SELECT pg_terminate_backend(pid) FROM pg_stat_activity WHERE datname = '${SCRATCH_DB_NAME}' AND pid <> pg_backend_pid()`,
    );
    await admin.$executeRawUnsafe(`DROP DATABASE IF EXISTS ${SCRATCH_DB_NAME}`);
    await admin.$executeRawUnsafe(`DROP ROLE IF EXISTS ${SCRATCH_ROLE_NAME}`);
    await admin.$executeRawUnsafe(`CREATE DATABASE ${SCRATCH_DB_NAME}`);
    await admin.$executeRawUnsafe(
      `CREATE ROLE ${SCRATCH_ROLE_NAME} WITH LOGIN NOSUPERUSER NOBYPASSRLS NOCREATEDB NOCREATEROLE PASSWORD '${SCRATCH_ROLE_PASSWORD}'`,
    );
  });

  const scratchAdminUrl = urlForDatabase(adminUrl, SCRATCH_DB_NAME).toString();
  await withAdminPrisma(scratchAdminUrl, async (db) => {
    await db.$executeRawUnsafe(`
      CREATE TABLE probe (
        id serial PRIMARY KEY,
        "tenantId" text NOT NULL,
        label text NOT NULL
      );
    `);
    await db.$executeRawUnsafe(`
      CREATE OR REPLACE FUNCTION current_tenant_id() RETURNS TEXT AS $$
        SELECT current_setting('app.current_tenant', true);
      $$ LANGUAGE sql STABLE;
    `);
    await db.$executeRawUnsafe(`ALTER TABLE probe ENABLE ROW LEVEL SECURITY;`);
    await db.$executeRawUnsafe(`ALTER TABLE probe FORCE ROW LEVEL SECURITY;`);
    await db.$executeRawUnsafe(`
      CREATE POLICY tenant_isolation_policy ON probe
        USING ("tenantId" = current_tenant_id());
    `);
    await db.$executeRawUnsafe(`GRANT USAGE ON SCHEMA public TO ${SCRATCH_ROLE_NAME}`);
    await db.$executeRawUnsafe(
      `GRANT SELECT, INSERT, UPDATE, DELETE ON probe TO ${SCRATCH_ROLE_NAME}`,
    );
    await db.$executeRawUnsafe(
      `GRANT USAGE, SELECT ON ALL SEQUENCES IN SCHEMA public TO ${SCRATCH_ROLE_NAME}`,
    );
    await db.$executeRawUnsafe(
      `GRANT EXECUTE ON FUNCTION current_tenant_id() TO ${SCRATCH_ROLE_NAME}`,
    );
    await db.$executeRawUnsafe(
      `INSERT INTO probe ("tenantId", label) VALUES ('TENANT-A', 'a-row'), ('TENANT-B', 'b-row')`,
    );
  });
}

async function teardownScratchDatabase(adminUrl) {
  await withAdminPrisma(adminUrl, async (admin) => {
    await admin.$executeRawUnsafe(
      `SELECT pg_terminate_backend(pid) FROM pg_stat_activity WHERE datname = '${SCRATCH_DB_NAME}' AND pid <> pg_backend_pid()`,
    );
    await admin.$executeRawUnsafe(`DROP DATABASE IF EXISTS ${SCRATCH_DB_NAME}`);
    await admin.$executeRawUnsafe(`DROP ROLE IF EXISTS ${SCRATCH_ROLE_NAME}`);
  });
}

function report(results, kennung, passed, detail) {
  const status = passed ? 'bestanden' : 'FEHLGESCHLAGEN';
  console.log(`${kennung}: ${status} — ${detail}`);
  results.push({ kennung, passed, detail });
}

/**
 * Repliziert exakt das reparierte forTenant()-Muster aus
 * apps/api/src/prisma/prisma-tenant.extension.ts: set_config und die
 * eigentliche Abfrage als Array-Form von $transaction, also auf einer
 * gemeinsamen Verbindung.
 */
async function forTenantQuery(prisma, tenantId, queryFn) {
  const setTenantContext = prisma.$executeRaw`SELECT set_config('app.current_tenant', ${tenantId}, true)`;
  const [, result] = await prisma.$transaction([setTenantContext, queryFn(prisma)]);
  return result;
}

/**
 * Aufgabe 1 — misst die fuenf im Plan genannten Verhaltensweisen von
 * forTenant() unter der Rolle ohne BYPASSRLS.
 */
async function runForTenantChecks(scratchRoleUrl, results) {
  const prisma = new PrismaClient({ datasourceUrl: scratchRoleUrl });

  try {
    // 1+2: gleiche Verbindung UND gesetzter Kontext — als zwei Teilmessungen
    // einer einzigen Array-Transaktion, im selben Format wie die urspruengliche
    // Fehlerreproduktion (Backend-PID beim set_config-Schritt vs. Backend-PID
    // bei der eigentlichen Abfrage; siehe Kopfkommentar von
    // prisma-tenant.extension.ts: "inside tx"/"actual qry").
    const [setStepRow, queryStepRow] = await prisma.$transaction([
      prisma.$queryRaw`SELECT pg_backend_pid() AS pid, set_config('app.current_tenant', 'TENANT-A', true) AS applied`,
      prisma.$queryRaw`SELECT pg_backend_pid() AS pid, current_tenant_id() AS t`,
    ]).then(([setRows, queryRows]) => [setRows[0], queryRows[0]]);

    report(
      results,
      'gleiche-backend-verbindung',
      setStepRow.pid === queryStepRow.pid,
      `set_config-Schritt pg_backend_pid()=${setStepRow.pid}, Abfrage-Schritt pg_backend_pid()=${queryStepRow.pid}`,
    );
    report(
      results,
      'mandantenkontext-waehrend-abfrage-gesetzt',
      queryStepRow.t === 'TENANT-A',
      `current_tenant_id() waehrend der eigentlichen Abfrage=${JSON.stringify(queryStepRow.t)}`,
    );

    // 3+4: forTenant(A) liefert ausschliesslich Zeilen von A, keine von B.
    const rowsForA = await forTenantQuery(prisma, 'TENANT-A', (tx) =>
      tx.$queryRaw`SELECT "tenantId" FROM probe ORDER BY id`,
    );
    const onlyA = rowsForA.length > 0 && rowsForA.every((r) => r.tenantId === 'TENANT-A');
    report(
      results,
      'nur-eigene-mandanten-zeilen',
      onlyA,
      `forTenant(TENANT-A) liefert ${rowsForA.length} Zeile(n): ${JSON.stringify(rowsForA.map((r) => r.tenantId))}`,
    );

    const leaksB = rowsForA.some((r) => r.tenantId === 'TENANT-B');
    report(
      results,
      'keine-fremdmandanten-zeilen',
      !leaksB,
      leaksB ? 'Zeile von TENANT-B sichtbar unter forTenant(TENANT-A)' : 'keine Zeile von TENANT-B sichtbar',
    );

    // 5: ungebundener Zugriff derselben Rolle liefert null Zeilen.
    const unbound = await prisma.$queryRaw`SELECT "tenantId" FROM probe`;
    report(
      results,
      'ungebunden-liefert-null-zeilen',
      unbound.length === 0,
      `ungebundener SELECT liefert ${unbound.length} Zeile(n)`,
    );
  } finally {
    await prisma.$disconnect();
  }
}

function readAuthLookupMigrationSql() {
  const dirs = readdirSync(MIGRATIONS_DIR, { withFileTypes: true })
    .filter((entry) => entry.isDirectory() && entry.name.endsWith('_auth_lookup_functions'))
    .map((entry) => entry.name);
  if (dirs.length !== 1) return null;
  return readFileSync(join(MIGRATIONS_DIR, dirs[0], 'migration.sql'), 'utf-8');
}

/**
 * Aufgabe 2 — spielt die auth_lookup_*-Migration in die Wegwerf-Datenbank
 * ein (mit tessera_app durch die Wegwerf-Rolle ersetzt), legt zwei Benutzer
 * in zwei Mandanten an und misst unter der Rolle ohne BYPASSRLS:
 * Funktionsaufruf findet den Benutzer, gewoehnlicher SELECT auf "User"
 * liefert null Zeilen, Suche nach unbekanntem Namen liefert nichts.
 */
async function runAuthLookupChecks(adminUrl, scratchRoleUrl, results) {
  const migrationSql = readAuthLookupMigrationSql();
  if (!migrationSql) {
    report(
      results,
      'auth-lookup-migration-vorhanden',
      false,
      'Migrationsverzeichnis *_auth_lookup_functions nicht gefunden',
    );
    return;
  }

  await withAdminPrisma(urlForDatabase(adminUrl, SCRATCH_DB_NAME).toString(), async (db) => {
    await db.$executeRawUnsafe(`
      CREATE TABLE "User" (
        id text PRIMARY KEY,
        username text UNIQUE NOT NULL,
        email text UNIQUE,
        "tenantId" text NOT NULL,
        "passwordHash" text,
        "ldapDn" text,
        "isActive" boolean NOT NULL DEFAULT true,
        role text NOT NULL DEFAULT 'USER',
        "displayName" text,
        "mustChangePassword" boolean NOT NULL DEFAULT false
      );
    `);
    await db.$executeRawUnsafe(`ALTER TABLE "User" ENABLE ROW LEVEL SECURITY;`);
    await db.$executeRawUnsafe(`ALTER TABLE "User" FORCE ROW LEVEL SECURITY;`);
    await db.$executeRawUnsafe(
      `CREATE POLICY tenant_isolation_policy ON "User" USING ("tenantId" = current_tenant_id());`,
    );
    await db.$executeRawUnsafe(`GRANT SELECT, INSERT, UPDATE, DELETE ON "User" TO ${SCRATCH_ROLE_NAME}`);
    await db.$executeRawUnsafe(`
      INSERT INTO "User" (id, username, "tenantId", "passwordHash", "isActive")
      VALUES ('user-a', 'alice', 'TENANT-A', 'hash-a', true),
             ('user-b', 'bob', 'TENANT-B', 'hash-b', true);
    `);

    // Migration nutzt echte Postgres-ENUM-Werte fuer "role" (Typ "Role") —
    // die Wegwerf-Tabelle oben verwendet stattdessen text, das ist fuer die
    // hier gemessenen drei Verhaltensweisen ausreichend. Die Funktion
    // auth_lookup_user_by_username referenziert den Spaltentyp nicht direkt
    // (SELECT u.role liefert einfach den gespeicherten Wert), daher
    // funktioniert das ohne den ENUM-Typ anzulegen — mit einer Ausnahme:
    // die RETURNS TABLE-Deklaration der echten Migration nennt den Typ
    // "Role" explizit. Fuer die Wegwerf-Pruefung wird er hier nachgebildet.
    await db.$executeRawUnsafe(`
      DO $$ BEGIN
        CREATE TYPE "Role" AS ENUM ('USER', 'ADMIN', 'SUPER_ADMIN');
      EXCEPTION WHEN duplicate_object THEN NULL;
      END $$;
    `);
    await db.$executeRawUnsafe(`ALTER TABLE "User" ALTER COLUMN role DROP DEFAULT;`);
    await db.$executeRawUnsafe(`ALTER TABLE "User" ALTER COLUMN role TYPE "Role" USING role::"Role";`);
    await db.$executeRawUnsafe(`ALTER TABLE "User" ALTER COLUMN role SET DEFAULT 'USER'::"Role";`);

    await db.$executeRawUnsafe(`
      CREATE TABLE "PasswordResetToken" (
        id text PRIMARY KEY,
        token text UNIQUE NOT NULL,
        "userId" text NOT NULL REFERENCES "User"(id),
        "expiresAt" timestamp(3) NOT NULL,
        "usedAt" timestamp(3)
      );
    `);

    // Die echte Migration erteilt das Ausfuehrungsrecht ausschliesslich an
    // tessera_app — fuer die Wegwerf-Pruefung an die Scratch-Rolle
    // umgeleitet, ohne den Rest der Migration zu veraendern. Ueber
    // executeSqlScript (prisma db execute --file), weil die Migration
    // mehrere Anweisungen inklusive DO $$ ... $$-Bloecke enthaelt, die sich
    // nicht als einzelnes $executeRawUnsafe senden lassen.
  });

  const adaptedSql = migrationSql.replaceAll('tessera_app', SCRATCH_ROLE_NAME);
  executeSqlScript(urlForDatabase(adminUrl, SCRATCH_DB_NAME).toString(), adaptedSql);

  const prisma = new PrismaClient({ datasourceUrl: scratchRoleUrl });
  try {
    const found = await prisma.$queryRaw`SELECT * FROM auth_lookup_user_by_username('alice')`;
    report(
      results,
      'anmeldesuche-findet-benutzer',
      found.length === 1 && found[0].username === 'alice',
      `auth_lookup_user_by_username('alice') liefert ${found.length} Zeile(n)`,
    );

    const notFound = await prisma.$queryRaw`SELECT * FROM auth_lookup_user_by_username('unknown-user')`;
    report(
      results,
      'anmeldesuche-unbekannt-liefert-nichts-und-wirft-nicht',
      notFound.length === 0,
      `auth_lookup_user_by_username('unknown-user') liefert ${notFound.length} Zeile(n)`,
    );

    const rawSelect = await prisma.$queryRaw`SELECT * FROM "User"`;
    report(
      results,
      'gewoehnlicher-select-auf-user-liefert-null-zeilen',
      rawSelect.length === 0,
      `SELECT * FROM "User" liefert ${rawSelect.length} Zeile(n)`,
    );
  } finally {
    await prisma.$disconnect();
  }
}

/**
 * Liest die ausgelieferte RLS-Basismigration und schneidet die beiden
 * `CREATE POLICY`-Anweisungen fuer "LdapConfig" und "LdapFieldMapping" bis
 * zum abschliessenden Semikolon heraus (Vorbild: readAuthLookupMigrationSql).
 * Der Dateiname wird ueber ein Suffix gesucht, nicht hartkodiert — aber die
 * Groups-Migration endet ebenfalls auf "_rls_policies" und wird deshalb
 * ausdruecklich ausgeschlossen, sonst faende der Filter zwei Verzeichnisse.
 */
function readRlsPoliciesMigrationSql() {
  const dirs = readdirSync(MIGRATIONS_DIR, { withFileTypes: true })
    .filter(
      (entry) =>
        entry.isDirectory() &&
        entry.name.endsWith('_rls_policies') &&
        !entry.name.endsWith('_groups_rls_policies'),
    )
    .map((entry) => entry.name);
  if (dirs.length !== 1) return null;
  return readFileSync(join(MIGRATIONS_DIR, dirs[0], 'migration.sql'), 'utf-8');
}

function extractPolicySql(migrationSql, tableName) {
  const re = new RegExp(
    `CREATE POLICY tenant_isolation_policy ON "${tableName}"[\\s\\S]*?;`,
  );
  const match = migrationSql.match(re);
  return match ? match[0] : null;
}

/**
 * Aufgabe 1 (260909-ipc) — misst die fuenf im Plan genannten Verhaltensweisen
 * des Bereichs ldap unter der Rolle ohne BYPASSRLS, mit den beiden Policies
 * WORTGLEICH aus der ausgelieferten Migration statt im Werkzeug neu getippt
 * (T-IPC-08). Findet die Extraktion eine der beiden Policies nicht, meldet
 * dieser Abschnitt eine FEHLGESCHLAGENE Pruefung und bricht ab, statt mit
 * einer geratenen Policy weiterzumessen.
 */
async function runLdapAreaChecks(adminUrl, scratchRoleUrl, results) {
  const migrationSql = readRlsPoliciesMigrationSql();
  const ldapConfigPolicy = migrationSql
    ? extractPolicySql(migrationSql, 'LdapConfig')
    : null;
  const ldapFieldMappingPolicy = migrationSql
    ? extractPolicySql(migrationSql, 'LdapFieldMapping')
    : null;

  if (!ldapConfigPolicy || !ldapFieldMappingPolicy) {
    report(
      results,
      'ldap-policies-aus-migration-gefunden',
      false,
      'CREATE POLICY fuer "LdapConfig" und/oder "LdapFieldMapping" nicht in der ausgelieferten *_rls_policies-Migration gefunden',
    );
    return;
  }

  await withAdminPrisma(urlForDatabase(adminUrl, SCRATCH_DB_NAME).toString(), async (db) => {
    await db.$executeRawUnsafe(`
      CREATE TABLE "LdapConfig" (
        id text PRIMARY KEY,
        "tenantId" text NOT NULL,
        "serverUrl" text NOT NULL
      );
    `);
    await db.$executeRawUnsafe(`
      CREATE TABLE "LdapFieldMapping" (
        id text PRIMARY KEY,
        "ldapConfigId" text NOT NULL REFERENCES "LdapConfig"(id),
        "ldapField" text NOT NULL,
        "tesseraField" text NOT NULL
      );
    `);
    await db.$executeRawUnsafe(`ALTER TABLE "LdapConfig" ENABLE ROW LEVEL SECURITY;`);
    await db.$executeRawUnsafe(`ALTER TABLE "LdapConfig" FORCE ROW LEVEL SECURITY;`);
    await db.$executeRawUnsafe(`ALTER TABLE "LdapFieldMapping" ENABLE ROW LEVEL SECURITY;`);
    await db.$executeRawUnsafe(`ALTER TABLE "LdapFieldMapping" FORCE ROW LEVEL SECURITY;`);
    await db.$executeRawUnsafe(ldapConfigPolicy);
    await db.$executeRawUnsafe(ldapFieldMappingPolicy);
    await db.$executeRawUnsafe(
      `GRANT SELECT, INSERT, UPDATE, DELETE ON "LdapConfig" TO ${SCRATCH_ROLE_NAME}`,
    );
    await db.$executeRawUnsafe(
      `GRANT SELECT, INSERT, UPDATE, DELETE ON "LdapFieldMapping" TO ${SCRATCH_ROLE_NAME}`,
    );
    await db.$executeRawUnsafe(`
      INSERT INTO "LdapConfig" (id, "tenantId", "serverUrl") VALUES
        ('cfg-a', 'TENANT-A', 'ldap://a.example'),
        ('cfg-b', 'TENANT-B', 'ldap://b.example');
    `);
    await db.$executeRawUnsafe(`
      INSERT INTO "LdapFieldMapping" (id, "ldapConfigId", "ldapField", "tesseraField") VALUES
        ('map-a', 'cfg-a', 'sAMAccountName', 'username'),
        ('map-b', 'cfg-b', 'sAMAccountName', 'username');
    `);
  });

  const prisma = new PrismaClient({ datasourceUrl: scratchRoleUrl });
  try {
    // 1: forTenant(TENANT-A) sieht genau die LdapConfig-Zeile von A.
    const configRowsForA = await forTenantQuery(prisma, 'TENANT-A', (tx) =>
      tx.$queryRaw`SELECT "tenantId" FROM "LdapConfig" ORDER BY id`,
    );
    report(
      results,
      'ldapconfig-gebunden-nur-eigene-zeile',
      configRowsForA.length === 1 && configRowsForA[0].tenantId === 'TENANT-A',
      `forTenant(TENANT-A) liefert ${configRowsForA.length} Zeile(n): ${JSON.stringify(configRowsForA.map((r) => r.tenantId))}`,
    );

    // 2: derselbe SELECT ohne Bindung liefert 0 Zeilen — die Fehlerrichtung,
    // an der echten Policy gemessen statt an der Hilfstabelle "probe".
    const unboundConfigRows = await prisma.$queryRaw`SELECT "tenantId" FROM "LdapConfig"`;
    report(
      results,
      'ldapconfig-ungebunden-null-zeilen',
      unboundConfigRows.length === 0,
      `ungebundener SELECT auf "LdapConfig" liefert ${unboundConfigRows.length} Zeile(n)`,
    );

    // 3: forTenant(TENANT-A) sieht ueber den Join genau die Feldzuordnung,
    // die an A's Konfiguration haengt.
    const mappingRowsForA = await forTenantQuery(prisma, 'TENANT-A', (tx) =>
      tx.$queryRaw`SELECT "ldapConfigId" FROM "LdapFieldMapping" ORDER BY id`,
    );
    report(
      results,
      'fieldmapping-folgt-join-auf-ldapconfig',
      mappingRowsForA.length === 1 && mappingRowsForA[0].ldapConfigId === 'cfg-a',
      `forTenant(TENANT-A) liefert ${mappingRowsForA.length} Feldzuordnung(en): ${JSON.stringify(mappingRowsForA.map((r) => r.ldapConfigId))}`,
    );

    // 4: gebundenes INSERT mit A's eigener ldapConfigId gelingt.
    let ownInsertOk = false;
    let ownInsertDetail = '';
    try {
      await forTenantQuery(
        prisma,
        'TENANT-A',
        (tx) =>
          tx.$executeRaw`INSERT INTO "LdapFieldMapping" (id, "ldapConfigId", "ldapField", "tesseraField") VALUES ('map-a-2', 'cfg-a', 'mail', 'email')`,
      );
      ownInsertOk = true;
      ownInsertDetail = 'INSERT mit eigener ldapConfigId erfolgreich';
    } catch (err) {
      ownInsertDetail = `INSERT mit eigener ldapConfigId fehlgeschlagen: ${err.message}`;
    }
    report(results, 'fieldmapping-schreiben-eigene-konfiguration-erlaubt', ownInsertOk, ownInsertDetail);

    // 5: gebundenes INSERT unter TENANT-A mit B's ldapConfigId wird
    // abgewiesen — die Abweisung IST das bestandene Ergebnis.
    let foreignInsertRejected = false;
    let foreignInsertDetail = '';
    try {
      await forTenantQuery(
        prisma,
        'TENANT-A',
        (tx) =>
          tx.$executeRaw`INSERT INTO "LdapFieldMapping" (id, "ldapConfigId", "ldapField", "tesseraField") VALUES ('map-foreign', 'cfg-b', 'mail', 'email')`,
      );
      foreignInsertDetail = 'INSERT mit fremder ldapConfigId ist NICHT fehlgeschlagen';
    } catch (err) {
      foreignInsertRejected = true;
      foreignInsertDetail = `INSERT mit fremder ldapConfigId abgewiesen: ${err.message}`;
    }
    report(
      results,
      'fieldmapping-schreiben-fremde-konfiguration-abgelehnt',
      foreignInsertRejected,
      foreignInsertDetail,
    );
  } finally {
    await prisma.$disconnect();
  }
}

async function main() {
  const adminUrl = parseAdminUrl();
  const results = [];

  console.log(`Richte Wegwerf-Datenbank "${SCRATCH_DB_NAME}" ein...`);
  await setupScratchDatabase(adminUrl);

  try {
    const scratchRoleUrl = urlForDatabase(adminUrl, SCRATCH_DB_NAME);
    scratchRoleUrl.username = SCRATCH_ROLE_NAME;
    scratchRoleUrl.password = SCRATCH_ROLE_PASSWORD;
    const scratchRoleUrlString = scratchRoleUrl.toString();

    await runForTenantChecks(scratchRoleUrlString, results);
    await runAuthLookupChecks(adminUrl, scratchRoleUrlString, results);
    await runLdapAreaChecks(adminUrl, scratchRoleUrlString, results);
  } finally {
    console.log(`Raeume Wegwerf-Datenbank "${SCRATCH_DB_NAME}" ab...`);
    await teardownScratchDatabase(adminUrl);
  }

  const allPassed = results.every((r) => r.passed);
  console.log(
    allPassed
      ? `Alle ${results.length} Pruefungen bestanden.`
      : `${results.filter((r) => !r.passed).length} von ${results.length} Pruefungen fehlgeschlagen.`,
  );
  process.exit(allPassed ? 0 : 1);
}

main().catch((err) => {
  console.error('FEHLER beim Ausfuehren der Wegwerf-Pruefung:', err.message);
  process.exit(1);
});