> ## 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.

# Esempi RLS

> Pattern pratici di Row-Level Security per tipi comuni di applicazioni.

<Warning>
  Questa pagina fa parte di una skill per agenti IA di programmazione ed è scritta per gli agenti, non per gli umani. Per la documentazione Base44 leggibile dagli umani, consulta la [documentazione per sviluppatori](/developers).
</Warning>

# Esempi RLS

Pattern pratici di Row-Level Security per tipi comuni di applicazioni.

**Importante:** Base44 RLS supporta:

* **Operatori logici:** `$or`, `$and`, `$nor` per combinare condizioni
* **Operatori sui campi (per i campi `data.*`):** `$in`, `$nin`, `$ne`, `$all`
* **user\_condition:** solo uguaglianza (nessun operatore)

## Contenuti

* [Pattern semplici (JSON Schema)](#simple-patterns-json-schema)
* [Uso degli operatori](#using-operators)
* [Esempi di sicurezza a livello di campo](#field-level-security-examples)
* [Pattern complessi (interfaccia Dashboard o backend)](#complex-patterns-dashboard-ui-or-backend)
* [Migliori pratiche](#best-practices)

***

## Pattern semplici (JSON Schema)

Questi pattern funzionano con il formato RLS JSON schema.

### App Todo - accesso solo al proprietario

Gli utenti vedono e gestiscono solo le proprie attività.

```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}}" }
  }
}
```

### Modulo di contatto - creazione pubblica, lettura solo admin

Chiunque può inviare, solo gli admin possono visualizzare le sottomissioni.

```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" } }
  }
}
```

### Profilo utente - auto-gestione

Gli utenti possono accedere solo al proprio profilo.

```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}}" }
  }
}
```

### Dati di dipartimento - accesso allo stesso dipartimento

Gli utenti possono vedere solo i record del proprio dipartimento.

```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" } }
  }
}
```

### Abbonamento - gestito dall'admin, leggibile dall'utente tramite campo email

```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" } }
  }
}
```

**Nota:** questo pattern permette solo agli utenti di leggere il proprio abbonamento. Gli admin devono usare l'interfaccia Dashboard per configurare l'accesso in lettura aggiuntivo per se stessi.

### Dati privati - solo proprietario

```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}}" }
  }
}
```

### Lettura pubblica, scrittura autenticata

Chiunque può leggere, solo gli utenti loggati possono creare/modificare i propri record.

```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}}" }
  }
}
```

***

## Uso degli operatori

### Operatori logici

Combina più condizioni usando `$or`, `$and` o `$nor`:

**Accesso proprietario O admin:**

```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" } }
  }
}
```

**Più ruoli con \$or:**

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

### Operatori sui campi per campi data.\*

Usa `$in`, `$nin`, `$ne`, `$all` per confrontare i campi data delle entità:

**Accesso in base ai tag (\$in):**

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

**Escludi stati specifici (\$nin):**

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

**Non uguale (\$ne):**

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

**Tutti i tag devono corrispondere (\$all):**

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

### Combinare operatori logici e sui campi

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

***

## Esempi di sicurezza a livello di campo

Controlla l'accesso a campi specifici all'interno di un'entità.

### Campo sensibile stipendio

```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" } }
      }
    }
  }
}
```

### Campi interni solo admin

```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
      }
    }
  }
}
```

***

## Pattern complessi (interfaccia Dashboard o backend)

Alcuni pattern potrebbero comunque richiedere l'interfaccia Dashboard o le funzioni backend.

### Relazioni bidirezionali (ad es. amicizie, match)

**Requisito:** entrambe le parti in una relazione dovrebbero avere accesso.

**Ora possibile con \$or:**

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

**Soluzioni alternative:**

1. **Ridisegno dell'entità:** memorizza due record per relazione (uno per ogni parte)
2. **Funzione backend:** interroga con logica personalizzata

### Logica di business complessa

**Requisito:** l'accesso dipende da più campi entità con condizioni complesse.

**Limitazione JSON Schema:** anche se gli operatori aiutano, la logica di business molto complessa potrebbe comunque essere difficile da esprimere.

**Opzioni di soluzione:**

1. **Funzione backend:** implementa la logica di accesso personalizzata
2. **Combina regole più semplici:** dividi le regole complesse in regole più semplici a livello di entità e di campo

***

## Migliori pratiche

### Strategia di sicurezza

Usa una combinazione di RLS a livello di entità e sicurezza a livello di campo:

| Tipo di dato             | Approccio                     | Esempio                                |
| ------------------------ | ----------------------------- | -------------------------------------- |
| Modificabile dall'utente | RLS entità: solo proprietario | UserProfile con controllo `created_by` |
| Campi sensibili          | RLS a livello di campo        | Campo stipendio con controllo ruolo HR |
| Accesso multi-ruolo      | `$or` con user\_condition     | Accesso admin O manager                |
| Accesso condizionale     | Operatori sui campi           | `$in`, `$ne` su campi data             |
| Contenuto pubblico       | RLS entità: `read: true`      | PublicPost                             |
| Contenuto privato        | RLS entità: solo proprietario | PrivateNote                            |

### Quando usare ogni approccio

| Requisito                                              | Approccio                                |
| ------------------------------------------------------ | ---------------------------------------- |
| Condizione singola (proprietario, admin, dipartimento) | RLS JSON Schema                          |
| Più condizioni OR/AND                                  | RLS JSON Schema con `$or`/`$and`         |
| Controlli sui valori dei campi con `$in`/`$ne`/ecc.    | RLS JSON Schema per campi `data.*`       |
| Controllo di accesso a livello di campo                | FLS JSON Schema (rls a livello di campo) |
| Operatori di confronto complessi (`$gt`, `$lt`)        | Funzioni backend                         |
| Logica di business molto complessa                     | Funzioni backend                         |

### Pattern comuni di ruoli

| Ruolo       | Accesso tipico                                          |
| ----------- | ------------------------------------------------------- |
| `admin`     | Accesso completo a tutti i record                       |
| `moderator` | Accesso in lettura/aggiornamento, eliminazione limitata |
| `manager`   | Accesso a livello di dipartimento                       |
| `user`      | Solo record propri                                      |

### Riepilogo degli operatori supportati

| Operatore                    | Supportato | Note                                     |
| ---------------------------- | ---------- | ---------------------------------------- |
| `$or`                        | Sì         | Combina più condizioni                   |
| `$and`                       | Sì         | Tutte le condizioni devono corrispondere |
| `$nor`                       | Sì         | Nessuna delle condizioni corrisponde     |
| `$in`                        | Sì         | Solo per campi `data.*`                  |
| `$nin`                       | Sì         | Solo per campi `data.*`                  |
| `$ne`                        | Sì         | Solo per campi `data.*`                  |
| `$all`                       | Sì         | Solo per campi `data.*`                  |
| `$gt`, `$lt`, `$gte`, `$lte` | No         | Usa funzioni backend                     |
| `$regex`                     | No         | Usa funzioni backend                     |

### Riepilogo delle limitazioni

| Non supportato                        | Alternativa                                 |
| ------------------------------------- | ------------------------------------------- |
| Operatori su `user_condition`         | Usa solo uguaglianza per i controlli utente |
| Operatori di confronto (`$gt`, `$lt`) | Funzioni backend                            |
| Corrispondenza regex (`$regex`)       | Funzioni backend                            |
| Relazioni tra entità                  | Funzioni backend                            |

<Note>Questa pagina è stata tradotta utilizzando l'IA. Per informazioni più accurate e aggiornate, consulta la [versione inglese](/). </Note>