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.

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)
Operatoren verwenden
Field-Level-Security-Beispiele
Komplexe Muster (Dashboard-UI oder Backend)
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.

{
  "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.

{
  "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.

{
  "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.

{
  "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

{
  "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

{
  "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.

{
  "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:

{
  "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:

{
  "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):

{
  "rls": {
    "read": {
      "data.category": { "$in": ["public", "shared"] }
    }
  }
}

Bestimmte Status ausschließen ($nin):

{
  "rls": {
    "read": {
      "data.status": { "$nin": ["archived", "deleted"] }
    }
  }
}

Nicht gleich ($ne):

{
  "rls": {
    "read": {
      "data.visibility": { "$ne": "private" }
    }
  }
}

Alle Tags müssen passen ($all):

{
  "rls": {
    "read": {
      "data.required_tags": { "$all": ["approved", "reviewed"] }
    }
  }
}

Logische und Feldoperatoren kombinieren

{
  "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

{
  "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

{
  "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:

{
  "rls": {
    "read": {
      "$or": [
        { "data.user_a_email": "{{user.email}}" },
        { "data.user_b_email": "{{user.email}}" }
      ]
    }
  }
}

Alternative Lösungen:

Entitäts-Umbau: Speichere zwei Datensätze pro Beziehung (einen pro Partei)
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:

Backend-Funktion: Benutzerdefinierte Zugriffslogik implementieren
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

Diese Seite wurde mit KI übersetzt. Für die genauesten und aktuellsten Informationen siehe die englische Version.

​RLS-Beispiele

​Inhalt

​Einfache Muster (JSON-Schema)

​Todo-App — Nur-Besitzer-Zugriff

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

​Nutzerprofil — Selbstverwaltung

​Abteilungsdaten — Zugriff für gleiche Abteilung

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

​Private Daten — Nur Besitzer

​Öffentlich lesen, authentifiziert schreiben

​Operatoren verwenden

​Logische Operatoren

​Feldoperatoren für data.*-Felder

​Logische und Feldoperatoren kombinieren

​Field-Level-Security-Beispiele

​Sensibles Gehaltsfeld

​Nur-Admin-interne Felder

​Komplexe Muster (Dashboard-UI oder Backend)

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

​Komplexe Geschäftslogik

​Best Practices

​Sicherheitsstrategie

​Wann welchen Ansatz verwenden

​Häufige Rollenmuster

​Zusammenfassung unterstützter Operatoren

​Zusammenfassung der Einschränkungen

RLS-Beispiele

Inhalt

Einfache Muster (JSON-Schema)

Todo-App — Nur-Besitzer-Zugriff

Kontaktformular — Öffentliches Erstellen, nur-Admin-Lesen

Nutzerprofil — Selbstverwaltung

Abteilungsdaten — Zugriff für gleiche Abteilung

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

Private Daten — Nur Besitzer

Öffentlich lesen, authentifiziert schreiben

Operatoren verwenden

Logische Operatoren

Feldoperatoren für data.*-Felder

Logische und Feldoperatoren kombinieren

Field-Level-Security-Beispiele

Sensibles Gehaltsfeld

Nur-Admin-interne Felder

Komplexe Muster (Dashboard-UI oder Backend)

Bidirektionale Beziehungen (z. B. Freundschaften, Matches)

Komplexe Geschäftslogik

Best Practices

Sicherheitsstrategie

Wann welchen Ansatz verwenden

Häufige Rollenmuster

Zusammenfassung unterstützter Operatoren

Zusammenfassung der Einschränkungen