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

# Ejemplos de RLS

> Patrones prácticos de seguridad a nivel de fila para tipos de aplicaciones comunes.

<Warning>
  Esta página es parte de una habilidad de agente de codificación con IA y está escrita para agentes, no para humanos. Para la documentación de Base44 legible por humanos, consulta la [documentación para desarrolladores](/developers).
</Warning>

# Ejemplos de RLS

Patrones prácticos de seguridad a nivel de fila para tipos de aplicaciones comunes.

**Importante:** El RLS de Base44 admite:

* **Operadores lógicos:** `$or`, `$and`, `$nor` para combinar condiciones
* **Operadores de campo (para campos `data.*`):** `$in`, `$nin`, `$ne`, `$all`
* **user\_condition:** Solo igualdad (sin operadores)

## Contenido

* [Patrones simples (JSON Schema)](#simple-patterns-json-schema)
* [Uso de operadores](#using-operators)
* [Ejemplos de seguridad a nivel de campo](#field-level-security-examples)
* [Patrones complejos (UI del panel o backend)](#complex-patterns-dashboard-ui-or-backend)
* [Mejores prácticas](#best-practices)

***

## Patrones simples (JSON Schema)

Estos patrones funcionan con el formato RLS de esquema JSON.

### App de tareas - Acceso solo del propietario

Los usuarios ven y gestionan solo sus propias tareas.

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

### Formulario de contacto - Creación pública, lectura solo de administrador

Cualquiera puede enviar, solo los administradores pueden ver los envíos.

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

### Perfil de usuario - Autogestión

Los usuarios solo pueden acceder a su propio perfil.

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

### Datos de departamento - Acceso del mismo departamento

Los usuarios solo pueden ver registros de su departamento.

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

### Suscripción - Gestión de administrador, legible por usuario mediante campo de correo

```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:** Este patrón solo permite a los usuarios leer su propia suscripción. Los administradores necesitan usar la UI del panel para configurar acceso de lectura adicional para sí mismos.

### Datos privados - Solo del propietario

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

### Lectura pública, escritura autenticada

Cualquiera puede leer, solo usuarios registrados pueden crear/editar sus propios registros.

```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 de operadores

### Operadores lógicos

Combina múltiples condiciones usando `$or`, `$and` o `$nor`:

**Acceso de propietario O administrador:**

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

**Múltiples roles con \$or:**

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

### Operadores de campo para campos data.\*

Usa `$in`, `$nin`, `$ne`, `$all` para comparar campos de datos de entidad:

**Acceso basado en etiquetas (\$in):**

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

**Excluir estados específicos (\$nin):**

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

**No igual (\$ne):**

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

**Todas las etiquetas deben coincidir (\$all):**

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

### Combinar operadores lógicos y de campo

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

***

## Ejemplos de seguridad a nivel de campo

Controla el acceso a campos específicos dentro de una entidad.

### Campo salary sensible

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

### Campos internos solo de administrador

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

***

## Patrones complejos (UI del panel o backend)

Algunos patrones aún pueden requerir la UI del panel o funciones de backend.

### Relaciones bidireccionales (por ejemplo, amistades, coincidencias)

**Requisito:** Cualquiera de las partes en una relación debe tener acceso.

**Ahora posible con \$or:**

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

**Soluciones alternativas:**

1. **Rediseño de entidad:** Almacena dos registros por relación (uno para cada parte)
2. **Función de backend:** Consulta con lógica personalizada

### Lógica de negocio compleja

**Requisito:** El acceso depende de múltiples campos de entidad con condiciones complejas.

**Limitación del esquema JSON:** Aunque los operadores ayudan, la lógica de negocio muy compleja aún puede ser difícil de expresar.

**Opciones de solución:**

1. **Función de backend:** Implementa lógica de acceso personalizada
2. **Combina reglas más simples:** Divide reglas complejas en reglas más simples a nivel de entidad y a nivel de campo

***

## Mejores prácticas

### Estrategia de seguridad

Usa una combinación de RLS a nivel de entidad y seguridad a nivel de campo:

| Tipo de dato            | Enfoque                          | Ejemplo                                   |
| ----------------------- | -------------------------------- | ----------------------------------------- |
| Editable por el usuario | RLS de entidad: solo propietario | UserProfile con comprobación `created_by` |
| Campos sensibles        | RLS a nivel de campo             | Campo salary con comprobación de rol HR   |
| Acceso multi-rol        | `$or` con user\_condition        | Acceso Admin O Manager                    |
| Acceso condicional      | Operadores de campo              | `$in`, `$ne` en campos de datos           |
| Contenido público       | RLS de entidad: `read: true`     | PublicPost                                |
| Contenido privado       | RLS de entidad: solo propietario | PrivateNote                               |

### Cuándo usar cada enfoque

| Requisito                                             | Enfoque                                      |
| ----------------------------------------------------- | -------------------------------------------- |
| Condición única (propietario, admin, departamento)    | RLS de esquema JSON                          |
| Múltiples condiciones OR/AND                          | RLS de esquema JSON con `$or`/`$and`         |
| Comprobaciones de valor de campo con `$in`/`$ne`/etc. | RLS de esquema JSON para campos `data.*`     |
| Control de acceso a nivel de campo                    | FLS de esquema JSON (`rls` a nivel de campo) |
| Operadores de comparación complejos (`$gt`, `$lt`)    | Funciones de backend                         |
| Lógica de negocio muy compleja                        | Funciones de backend                         |

### Patrones de roles comunes

| Rol         | Acceso típico                                         |
| ----------- | ----------------------------------------------------- |
| `admin`     | Acceso total a todos los registros                    |
| `moderator` | Acceso de lectura/actualización, eliminación limitada |
| `manager`   | Acceso limitado al departamento                       |
| `user`      | Solo sus propios registros                            |

### Resumen de operadores admitidos

| Operador                     | Admitido | Notas                                 |
| ---------------------------- | -------- | ------------------------------------- |
| `$or`                        | Sí       | Combina múltiples condiciones         |
| `$and`                       | Sí       | Todas las condiciones deben coincidir |
| `$nor`                       | Sí       | Ninguna de las condiciones coincide   |
| `$in`                        | Sí       | Solo para campos `data.*`             |
| `$nin`                       | Sí       | Solo para campos `data.*`             |
| `$ne`                        | Sí       | Solo para campos `data.*`             |
| `$all`                       | Sí       | Solo para campos `data.*`             |
| `$gt`, `$lt`, `$gte`, `$lte` | No       | Usa funciones de backend              |
| `$regex`                     | No       | Usa funciones de backend              |

### Resumen de limitaciones

| No admitido                              | Alternativa                                      |
| ---------------------------------------- | ------------------------------------------------ |
| Operadores en `user_condition`           | Usa solo igualdad para comprobaciones de usuario |
| Operadores de comparación (`$gt`, `$lt`) | Funciones de backend                             |
| Coincidencia con regex (`$regex`)        | Funciones de backend                             |
| Relaciones entre entidades               | Funciones de backend                             |

<Note>Esta página fue traducida usando IA. Para obtener la información más precisa y actualizada, consulta la [versión en inglés](/).</Note>