> ## Documentation Index
> Fetch the complete documentation index at: https://docs.base44.com/llms.txt
> Use this file to discover all available pages before exploring further.

# RLS-Beispiele

> Praktische Row-Level-Security-Muster für gängige Anwendungstypen.

<Warning>
  Diese Seite ist Teil eines KI-Coding-Agent-Skills und für Agenten geschrieben, nicht für Menschen. Für die menschenlesbare Base44-Dokumentation siehe die [Entwicklerdokumentation](/developers).
</Warning>

# RLS-Beispiele

Praktische Row-Level-Security-Muster für gängige Anwendungstypen.

**Wichtig:** Base44 RLS unterstützt:

* **Logische Operatoren:** `$or`, `$and`, `$nor` zum Kombinieren von Bedingungen
* **Feldoperatoren (für `data.*`-Felder):** `$in`, `$nin`, `$ne`, `$all`
* **user\_condition:** Nur Gleichheit (keine Operatoren)

## Inhalt

* [Einfache Muster (JSON-Schema)](#einfache-muster-json-schema)
* [Operatoren verwenden](#operatoren-verwenden)
* [Field-Level-Security-Beispiele](#field-level-security-beispiele)
* [Komplexe Muster (Dashboard-UI oder Backend)](#komplexe-muster-dashboard-ui-oder-backend)
* [Best Practices](#best-practices)

***

## Einfache Muster (JSON-Schema)

Diese Muster funktionieren mit dem JSON-Schema-RLS-Format.

### Todo-App — Nur-Besitzer-Zugriff

Nutzer sehen und verwalten nur ihre eigenen Aufgaben.

```jsonc theme={null}
{
  "name": "Task",
  "type": "object",
  "properties": {
    "title": { "type": "string" },
    "description": { "type": "string" },
    "completed": { "type": "boolean" },
    "priority": { "type": "string", "enum": ["low", "medium", "high"] },
    "due_date": { "type": "string", "format": "date" }
  },
  "rls": {
    "create": true,
    "read": { "created_by": "{{user.email}}" },
    "update": { "created_by": "{{user.email}}" },
    "delete": { "created_by": "{{user.email}}" }
  }
}
```

### Kontaktformular — Öffentliches Erstellen, nur-Admin-Lesen

Jeder kann einreichen, nur Admins können Einträge ansehen.

```jsonc theme={null}
{
  "name": "ContactSubmission",
  "type": "object",
  "properties": {
    "name": { "type": "string" },
    "email": { "type": "string", "format": "email" },
    "message": { "type": "string" }
  },
  "rls": {
    "create": true,
    "read": { "user_condition": { "role": "admin" } },
    "update": { "user_condition": { "role": "admin" } },
    "delete": { "user_condition": { "role": "admin" } }
  }
}
```

### Nutzerprofil — Selbstverwaltung

Nutzer können nur auf ihr eigenes Profil zugreifen.

```jsonc theme={null}
{
  "name": "UserProfile",
  "type": "object",
  "properties": {
    "name": { "type": "string" },
    "avatar_url": { "type": "string" },
    "bio": { "type": "string" },
    "preferences": { "type": "object" }
  },
  "rls": {
    "create": true,
    "read": { "created_by": "{{user.email}}" },
    "update": { "created_by": "{{user.email}}" },
    "delete": { "created_by": "{{user.email}}" }
  }
}
```

### Abteilungsdaten — Zugriff für gleiche Abteilung

Nutzer sehen nur Datensätze aus ihrer Abteilung.

```jsonc theme={null}
{
  "name": "DepartmentAnnouncement",
  "type": "object",
  "properties": {
    "title": { "type": "string" },
    "content": { "type": "string" },
    "department": { "type": "string" }
  },
  "rls": {
    "create": { "user_condition": { "role": "manager" } },
    "read": { "data.department": "{{user.data.department}}" },
    "update": { "user_condition": { "role": "manager" } },
    "delete": { "user_condition": { "role": "admin" } }
  }
}
```

### Abo — Admin-verwaltet, für Nutzer über E-Mail-Feld lesbar

```jsonc theme={null}
{
  "name": "Subscription",
  "type": "object",
  "properties": {
    "user_email": { "type": "string" },
    "tier": { "type": "string", "enum": ["free", "basic", "pro", "enterprise"] },
    "credits": { "type": "number" },
    "renewal_date": { "type": "string", "format": "date" }
  },
  "rls": {
    "create": { "user_condition": { "role": "admin" } },
    "read": { "data.user_email": "{{user.email}}" },
    "update": { "user_condition": { "role": "admin" } },
    "delete": { "user_condition": { "role": "admin" } }
  }
}
```

**Hinweis:** Dieses Muster erlaubt Nutzern nur, ihr eigenes Abo zu lesen. Admins müssen die Dashboard-UI verwenden, um zusätzlichen Lesezugriff für sich zu konfigurieren.

### Private Daten — Nur Besitzer

```jsonc theme={null}
{
  "name": "PrivateNotes",
  "type": "object",
  "properties": {
    "title": { "type": "string" },
    "content": { "type": "string" },
    "tags": { "type": "array", "items": { "type": "string" } }
  },
  "rls": {
    "create": true,
    "read": { "created_by": "{{user.email}}" },
    "update": { "created_by": "{{user.email}}" },
    "delete": { "created_by": "{{user.email}}" }
  }
}
```

### Öffentlich lesen, authentifiziert schreiben

Jeder kann lesen, nur eingeloggte Nutzer können ihre eigenen Datensätze erstellen/bearbeiten.

```jsonc theme={null}
{
  "name": "BlogPost",
  "type": "object",
  "properties": {
    "title": { "type": "string" },
    "content": { "type": "string" },
    "author_email": { "type": "string" }
  },
  "rls": {
    "create": true,
    "read": true,
    "update": { "created_by": "{{user.email}}" },
    "delete": { "created_by": "{{user.email}}" }
  }
}
```

***

## Operatoren verwenden

### Logische Operatoren

Kombiniere mehrere Bedingungen mit `$or`, `$and` oder `$nor`:

**Besitzer- ODER Admin-Zugriff:**

```jsonc theme={null}
{
  "name": "Document",
  "type": "object",
  "properties": {
    "title": { "type": "string" },
    "content": { "type": "string" }
  },
  "rls": {
    "create": true,
    "read": {
      "$or": [
        { "created_by": "{{user.email}}" },
        { "user_condition": { "role": "admin" } }
      ]
    },
    "update": {
      "$or": [
        { "created_by": "{{user.email}}" },
        { "user_condition": { "role": "admin" } }
      ]
    },
    "delete": { "user_condition": { "role": "admin" } }
  }
}
```

**Mehrere Rollen mit \$or:**

```jsonc theme={null}
{
  "rls": {
    "read": {
      "$or": [
        { "user_condition": { "role": "admin" } },
        { "user_condition": { "role": "manager" } },
        { "user_condition": { "role": "hr" } }
      ]
    }
  }
}
```

### Feldoperatoren für data.\*-Felder

Verwende `$in`, `$nin`, `$ne`, `$all` zum Vergleichen von Entitäts-Datenfeldern:

**Zugriff basierend auf Tags (\$in):**

```jsonc theme={null}
{
  "rls": {
    "read": {
      "data.category": { "$in": ["public", "shared"] }
    }
  }
}
```

**Bestimmte Status ausschließen (\$nin):**

```jsonc theme={null}
{
  "rls": {
    "read": {
      "data.status": { "$nin": ["archived", "deleted"] }
    }
  }
}
```

**Nicht gleich (\$ne):**

```jsonc theme={null}
{
  "rls": {
    "read": {
      "data.visibility": { "$ne": "private" }
    }
  }
}
```

**Alle Tags müssen passen (\$all):**

```jsonc theme={null}
{
  "rls": {
    "read": {
      "data.required_tags": { "$all": ["approved", "reviewed"] }
    }
  }
}
```

### Logische und Feldoperatoren kombinieren

```jsonc theme={null}
{
  "rls": {
    "read": {
      "$and": [
        { "data.status": { "$ne": "draft" } },
        {
          "$or": [
            { "created_by": "{{user.email}}" },
            { "data.visibility": "public" }
          ]
        }
      ]
    }
  }
}
```

***

## Field-Level-Security-Beispiele

Steuere den Zugriff auf bestimmte Felder innerhalb einer Entität.

### Sensibles Gehaltsfeld

```jsonc theme={null}
{
  "name": "Employee",
  "type": "object",
  "properties": {
    "name": { "type": "string" },
    "email": { "type": "string", "format": "email" },
    "salary": {
      "type": "number",
      "description": "Annual salary",
      "rls": {
        "read": { "user_condition": { "role": "hr" } },
        "write": { "user_condition": { "role": "hr" } }
      }
    },
    "performance_notes": {
      "type": "string",
      "description": "Manager notes",
      "rls": {
        "read": {
          "$or": [
            { "user_condition": { "role": "manager" } },
            { "user_condition": { "role": "hr" } }
          ]
        },
        "write": { "user_condition": { "role": "manager" } }
      }
    }
  }
}
```

### Nur-Admin-interne Felder

```jsonc theme={null}
{
  "name": "Order",
  "type": "object",
  "properties": {
    "order_number": { "type": "string" },
    "total": { "type": "number" },
    "internal_notes": {
      "type": "string",
      "description": "Internal processing notes",
      "rls": {
        "read": { "user_condition": { "role": "admin" } },
        "write": { "user_condition": { "role": "admin" } }
      }
    },
    "profit_margin": {
      "type": "number",
      "description": "Profit margin percentage",
      "rls": {
        "read": { "user_condition": { "role": "admin" } },
        "write": false
      }
    }
  }
}
```

***

## Komplexe Muster (Dashboard-UI oder Backend)

Manche Muster erfordern immer noch die Dashboard-UI oder Backend-Funktionen.

### Bidirektionale Beziehungen (z. B. Freundschaften, Matches)

**Anforderung:** Beide Parteien einer Beziehung sollen Zugriff haben.

**Jetzt mit \$or möglich:**

```jsonc theme={null}
{
  "rls": {
    "read": {
      "$or": [
        { "data.user_a_email": "{{user.email}}" },
        { "data.user_b_email": "{{user.email}}" }
      ]
    }
  }
}
```

**Alternative Lösungen:**

1. **Entitäts-Umbau:** Speichere zwei Datensätze pro Beziehung (einen pro Partei)
2. **Backend-Funktion:** Abfrage mit benutzerdefinierter Logik

### Komplexe Geschäftslogik

**Anforderung:** Zugriff hängt von mehreren Entitätsfeldern mit komplexen Bedingungen ab.

**JSON-Schema-Einschränkung:** Auch mit Operatoren kann sehr komplexe Geschäftslogik schwer auszudrücken sein.

**Lösungsoptionen:**

1. **Backend-Funktion:** Benutzerdefinierte Zugriffslogik implementieren
2. **Einfachere Regeln kombinieren:** Komplexe Regeln in einfachere Regeln auf Entitäts- und Feldebene aufteilen

***

## Best Practices

### Sicherheitsstrategie

Nutze eine Kombination aus Entitäts-RLS und Field-Level-Security:

| Datentyp                   | Ansatz                     | Beispiel                             |
| -------------------------- | -------------------------- | ------------------------------------ |
| Vom Nutzer editierbar      | Entitäts-RLS: Nur-Besitzer | UserProfile mit `created_by`-Prüfung |
| Sensible Felder            | Field-Level-RLS            | Gehaltsfeld mit HR-Rollenprüfung     |
| Zugriff für mehrere Rollen | `$or` mit user\_condition  | Admin- ODER Manager-Zugriff          |
| Bedingter Zugriff          | Feldoperatoren             | `$in`, `$ne` auf Datenfeldern        |
| Öffentlicher Inhalt        | Entitäts-RLS: `read: true` | PublicPost                           |
| Privater Inhalt            | Entitäts-RLS: Nur-Besitzer | PrivateNote                          |

### Wann welchen Ansatz verwenden

| Anforderung                                     | Ansatz                                |
| ----------------------------------------------- | ------------------------------------- |
| Einzelne Bedingung (Besitzer, Admin, Abteilung) | JSON-Schema-RLS                       |
| Mehrere ODER/UND-Bedingungen                    | JSON-Schema-RLS mit `$or`/`$and`      |
| Feldwertprüfungen mit `$in`/`$ne`/usw.          | JSON-Schema-RLS für `data.*`-Felder   |
| Feldebenen-Zugriffssteuerung                    | JSON-Schema-FLS (feldbezogenes `rls`) |
| Komplexe Vergleichsoperatoren (`$gt`, `$lt`)    | Backend-Funktionen                    |
| Sehr komplexe Geschäftslogik                    | Backend-Funktionen                    |

### Häufige Rollenmuster

| Rolle       | Typischer Zugriff                               |
| ----------- | ----------------------------------------------- |
| `admin`     | Vollzugriff auf alle Datensätze                 |
| `moderator` | Lese-/Änderungszugriff, eingeschränktes Löschen |
| `manager`   | Auf Abteilung beschränkter Zugriff              |
| `user`      | Nur eigene Datensätze                           |

### Zusammenfassung unterstützter Operatoren

| Operator                     | Unterstützt | Hinweise                          |
| ---------------------------- | ----------- | --------------------------------- |
| `$or`                        | Ja          | Mehrere Bedingungen kombinieren   |
| `$and`                       | Ja          | Alle Bedingungen müssen zutreffen |
| `$nor`                       | Ja          | Keine der Bedingungen trifft zu   |
| `$in`                        | Ja          | Nur für `data.*`-Felder           |
| `$nin`                       | Ja          | Nur für `data.*`-Felder           |
| `$ne`                        | Ja          | Nur für `data.*`-Felder           |
| `$all`                       | Ja          | Nur für `data.*`-Felder           |
| `$gt`, `$lt`, `$gte`, `$lte` | Nein        | Backend-Funktionen verwenden      |
| `$regex`                     | Nein        | Backend-Funktionen verwenden      |

### Zusammenfassung der Einschränkungen

| Nicht unterstützt                   | Alternative                                  |
| ----------------------------------- | -------------------------------------------- |
| Operatoren bei `user_condition`     | Nur Gleichheit bei Nutzerprüfungen verwenden |
| Vergleichsoperatoren (`$gt`, `$lt`) | Backend-Funktionen                           |
| Regex-Matching (`$regex`)           | Backend-Funktionen                           |
| Entitätsübergreifende Beziehungen   | Backend-Funktionen                           |

<Note>Diese Seite wurde mit KI übersetzt. Für die genauesten und aktuellsten Informationen siehe die [englische Version](/). </Note>