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

# Schémas d'entités

> Définissez des structures de données personnalisées en utilisant un JSON Schema avec des règles de validation et des types de champs

<div className="dev-docs-banner">
  <div className="dev-docs-banner-content">
    <div className="dev-docs-banner-title">
      Vous consultez la documentation pour développeurs
    </div>

    <div className="dev-docs-banner-text">
      Cette documentation est destinée aux développeurs travaillant avec la plateforme développeur Base44. Pour des informations sur la gestion des données de votre application via l'éditeur d'applications, consultez <a href="/Building-your-app/Managing-your-app-data">Gestion des données d'application</a>.
    </div>
  </div>
</div>

Les entités sont définies en utilisant un JSON Schema qui décrit la structure des données et les règles de validation.

## Structure de schéma de base

Les schémas d'entités sont définis dans des fichiers JSON dans le répertoire des entités de votre projet. Par défaut, c'est `base44/entities/`, mais vous pouvez personnaliser le chemin dans votre [configuration de projet](/developers/backend/overview/project-structure#config-jsonc). Le nom de fichier détermine le nom de l'entité. Par exemple, `Task.json` crée une entité `Task`.

Voici un modèle de schéma d'entité :

```json theme={null}
{
  "name": "my_entity",
  "type": "object",
  "title": "My Entity",
  "description": "Description of what this entity represents",
  "properties": {
    "<field_name>": {
      "type": "<field_type>",
      "<option>": "<value>"
    }
  },
  "required": ["<field_name>"]
}
```

## Champs intégrés

Chaque enregistrement d'entité inclut automatiquement les champs suivants. Ne définissez pas de champs avec ces noms dans votre schéma.

| Champ                    | Type     | Description                                                   |
| ------------------------ | -------- | ------------------------------------------------------------- |
| `id`                     | string   | Identifiant unique pour l'enregistrement                      |
| `created_date`           | datetime | Quand l'enregistrement a été créé                             |
| `updated_date`           | datetime | Quand l'enregistrement a été mis à jour pour la dernière fois |
| `created_by`             | string   | E-mail de l'utilisateur qui a créé l'enregistrement           |
| `created_by_id`          | string   | ID de l'utilisateur qui a créé l'enregistrement               |
| `is_deleted` (interne)   | boolean  | Indicateur de suppression douce                               |
| `deleted_date` (interne) | datetime | Quand l'enregistrement a été supprimé                         |
| `is_sample` (interne)    | boolean  | Si l'enregistrement est un échantillon de données             |
| `entity_name` (interne)  | string   | Nom du type d'entité                                          |
| `app_id` (interne)       | string   | ID de l'application                                           |
| `environment` (interne)  | string   | Soit `prod` soit `dev`                                        |

Les champs internes ne sont pas retournés dans les réponses API mais peuvent être référencés dans les [règles de sécurité](/developers/backend/resources/entities/security).

## Champs de schéma

<ResponseField name="name" type="string">
  Identifiant chaîne pour l'entité.
</ResponseField>

<ResponseField name="type" type="string" required>
  Doit être `"object"`.
</ResponseField>

<ResponseField name="title" type="string">
  Nom d'affichage convivial pour l'utilisateur.
</ResponseField>

<ResponseField name="description" type="string">
  Description de ce que représente l'entité.
</ResponseField>

<ResponseField name="properties" type="object" required>
  Objet contenant vos définitions de champs. Chaque champ a un `type` et des
  règles de validation facultatives.
</ResponseField>

## Types de champs

Les entités prennent en charge divers types de champs pour définir différents types de données que vous pouvez stocker : `string`, `integer`, `number`, `boolean`, `array` et `object`.
Chaque champ à l'intérieur de `properties` nécessite un `type`. En fonction du type, vous pouvez ajouter des options de validation.

### Champs string

Les champs string prennent en charge ces options :

* **`minLength`** / **`maxLength`** : contrôlent le nombre minimum et maximum de caractères.
* **`pattern`** : expression régulière pour validation personnalisée.
* **`format`** : formats prédéfinis. Valeurs prises en charge :
  * `"date"`
  * `"date-time"`
  * `"time"`
  * `"email"`
  * `"uri"`
  * `"hostname"`
  * `"ipv4"`
  * `"ipv6"`
  * `"uuid"`
* **`enum`** : restreindre à des valeurs spécifiques autorisées. Définissez sous forme de tableau : `["value1", "value2", "value3"]`.
* **`default`** : valeur par défaut si aucune n'est fournie.

### Champs integer

Les champs integer prennent en charge ces options :

* **`minimum`** / **`maximum`** : définissent les bornes inférieure/supérieure inclusives.
* **`default`** : valeur par défaut si aucune n'est fournie.

### Champs number

Les champs number prennent en charge ces options :

* **`minimum`** / **`maximum`** : définissent les bornes inférieure/supérieure inclusives.
* **`default`** : valeur par défaut si aucune n'est fournie.

### Champs boolean

Les champs boolean prennent en charge ces options :

* **`default`** : valeur par défaut si aucune n'est fournie.

### Champs array

Les champs array prennent en charge ces options :

* **`items`** : définit le type/schéma des éléments du tableau.
* **`default`** : valeur de tableau par défaut si aucune n'est fournie.

### Champs object

Les champs object prennent en charge ces options :

* **`properties`** : définit les champs à l'intérieur de l'objet.
* **`required`** : liste des noms de propriétés requises.

## Champs requis

Spécifiez quels champs doivent être fournis :

```json theme={null}
{
  "required": ["title", "email"]
}
```

## Exemple complet

Voici un schéma d'entité complet :

```json theme={null}
{
  "name": "Task",
  "type": "object",
  "title": "Task",
  "description": "A task item with priority, due date, and completion status",
  "properties": {
    "title": {
      "type": "string",
      "minLength": 1,
      "maxLength": 200
    },
    "description": {
      "type": "string",
      "maxLength": 1000
    },
    "priority": {
      "type": "string",
      "enum": ["low", "medium", "high"],
      "default": "medium"
    },
    "completed": {
      "type": "boolean",
      "default": false
    },
    "due_date": {
      "type": "string",
      "format": "date"
    },
    "tags": {
      "type": "array",
      "items": { "type": "string" }
    },
    "internal_notes": {
      "type": "string",
      "rls": {
        "read": {"user_condition": {"role": "admin"}},
        "write": {"user_condition": {"role": "admin"}}
      }
    }
  },
  "required": ["title"],
  "rls": {
    "create": true,
    "read": {"created_by": "{{user.email}}"},
    "update": {"created_by": "{{user.email}}"},
    "delete": {"created_by": "{{user.email}}"}
  }
}
```

## Déploiement des entités

Après avoir défini votre schéma d'entité, déployez-le sur Base44 en utilisant [`entities push`](/developers/references/cli/commands/entities-push). Les entités sont également déployées automatiquement lorsque vous exécutez la commande [`deploy`](/developers/references/cli/commands/deploy) pour déployer l'ensemble de votre projet.

Une fois déployées, vous pouvez interagir avec vos entités en utilisant le [module `entities` du SDK](/developers/references/sdk/docs/type-aliases/entities). Le nom de l'entité dans votre schéma doit correspondre exactement à la façon dont vous y accédez dans le SDK, y compris la capitalisation. Par exemple, si votre schéma a `"name": "Task"`, vous devez y accéder avec `base44.entities.Task.list()`.

Les schémas d'entités déployés peuvent être visualisés dans le tableau de bord dans la section **Data**.

## Voir aussi

* [Schéma utilisateur](/developers/backend/resources/entities/user-schema) : entité intégrée spéciale pour l'authentification utilisateur
* [Sécurité](/developers/backend/resources/entities/security) : configurer les règles de sécurité au niveau ligne pour les entités
* [Structure du projet](/developers/backend/overview/project-structure) : comment les schémas d'entités s'intègrent dans votre projet

<Note>Cette page a été traduite à l'aide de l'IA. Pour les informations les plus précises et à jour, consultez la [version anglaise](/). </Note>