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

# Schemi delle entità

> Definisci strutture dati personalizzate usando uno JSON Schema con regole di validazione e tipi di campo

<div className="dev-docs-banner">
  <div className="dev-docs-banner-content">
    <div className="dev-docs-banner-title">
      Stai visualizzando la documentazione per sviluppatori
    </div>

    <div className="dev-docs-banner-text">
      Questa documentazione è per sviluppatori che lavorano con la piattaforma per sviluppatori di Base44. Per informazioni sulla gestione dei dati della tua app usando l'editor, consulta <a href="/Building-your-app/Managing-your-app-data">Gestire i dati dell'app</a>.
    </div>
  </div>
</div>

Le entità sono definite usando uno JSON Schema che descrive la struttura dei dati e le regole di validazione.

## Struttura base dello schema

Gli schemi delle entità sono definiti in file JSON nella directory delle entità del tuo progetto. Per impostazione predefinita, è `base44/entities/`, ma puoi personalizzare il percorso nella [configurazione del progetto](/developers/backend/overview/project-structure#config-jsonc). Il nome del file determina il nome dell'entità. Ad esempio, `Task.json` crea un'entità `Task`.

Ecco un modello di schema di 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>"]
}
```

## Campi integrati

Ogni record di entità include automaticamente i seguenti campi. Non definire campi con questi nomi nel tuo schema.

| Campo                    | Tipo     | Descrizione                                        |
| ------------------------ | -------- | -------------------------------------------------- |
| `id`                     | string   | Identificatore univoco del record                  |
| `created_date`           | datetime | Quando il record è stato creato                    |
| `updated_date`           | datetime | Quando il record è stato aggiornato l'ultima volta |
| `created_by`             | string   | Email dell'utente che ha creato il record          |
| `created_by_id`          | string   | ID dell'utente che ha creato il record             |
| `is_deleted` (interno)   | boolean  | Flag di eliminazione soft                          |
| `deleted_date` (interno) | datetime | Quando il record è stato eliminato                 |
| `is_sample` (interno)    | boolean  | Se il record è dato di esempio                     |
| `entity_name` (interno)  | string   | Nome del tipo di entità                            |
| `app_id` (interno)       | string   | ID dell'app                                        |
| `environment` (interno)  | string   | `prod` oppure `dev`                                |

I campi interni non sono restituiti nelle risposte API ma possono essere referenziati nelle [regole di sicurezza](/developers/backend/resources/entities/security).

## Campi dello schema

<ResponseField name="name" type="string">
  Identificatore stringa per l'entità.
</ResponseField>

<ResponseField name="type" type="string" required>
  Deve essere `"object"`.
</ResponseField>

<ResponseField name="title" type="string">
  Nome visualizzato in modo leggibile.
</ResponseField>

<ResponseField name="description" type="string">
  Descrizione di ciò che l'entità rappresenta.
</ResponseField>

<ResponseField name="properties" type="object" required>
  Oggetto contenente le definizioni dei campi. Ogni campo ha un `type` e regole
  di validazione opzionali.
</ResponseField>

## Tipi di campo

Le entità supportano vari tipi di campo per definire diversi tipi di dati che puoi memorizzare: `string`, `integer`, `number`, `boolean`, `array` e `object`.
Ogni campo dentro `properties` richiede un `type`. In base al tipo, puoi aggiungere opzioni di validazione.

### Campi stringa

I campi stringa supportano queste opzioni:

* **`minLength`** / **`maxLength`**: controllano il numero minimo e massimo di caratteri.
* **`pattern`**: espressione regolare per la validazione personalizzata.
* **`format`**: formati predefiniti. Valori supportati:
  * `"date"`
  * `"date-time"`
  * `"time"`
  * `"email"`
  * `"uri"`
  * `"hostname"`
  * `"ipv4"`
  * `"ipv6"`
  * `"uuid"`
* **`enum`**: limita a valori specifici consentiti. Definisci come array: `["value1", "value2", "value3"]`.
* **`default`**: valore predefinito se non ne viene fornito uno.

### Campi interi

I campi interi supportano queste opzioni:

* **`minimum`** / **`maximum`**: impostano limiti inferiore/superiore inclusivi.
* **`default`**: valore predefinito se non ne viene fornito uno.

### Campi numerici

I campi numerici supportano queste opzioni:

* **`minimum`** / **`maximum`**: impostano limiti inferiore/superiore inclusivi.
* **`default`**: valore predefinito se non ne viene fornito uno.

### Campi booleani

I campi booleani supportano queste opzioni:

* **`default`**: valore predefinito se non ne viene fornito uno.

### Campi array

I campi array supportano queste opzioni:

* **`items`**: definisce il tipo/schema per gli elementi dell'array.
* **`default`**: valore array predefinito se non ne viene fornito uno.

### Campi oggetto

I campi oggetto supportano queste opzioni:

* **`properties`**: definisce i campi all'interno dell'oggetto.
* **`required`**: elenco dei nomi delle proprietà obbligatorie.

## Campi obbligatori

Specifica quali campi devono essere forniti:

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

## Esempio completo

Ecco uno schema di entità completo:

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

## Distribuzione delle entità

Dopo aver definito lo schema dell'entità, distribuiscilo a Base44 usando [`entities push`](/developers/references/cli/commands/entities-push). Le entità vengono anche distribuite automaticamente quando esegui il comando [`deploy`](/developers/references/cli/commands/deploy) per distribuire l'intero progetto.

Una volta distribuita, puoi interagire con le tue entità usando il [modulo `entities` dell'SDK](/developers/references/sdk/docs/type-aliases/entities). Il nome dell'entità nel tuo schema deve corrispondere esattamente a come vi accedi nell'SDK, incluse le maiuscole. Ad esempio, se il tuo schema ha `"name": "Task"`, devi accedervi come `base44.entities.Task.list()`.

Gli schemi delle entità distribuite possono essere visualizzati nella dashboard nella sezione **Data**.

## Vedi anche

* [Schema utente](/developers/backend/resources/entities/user-schema): entità integrata speciale per l'autenticazione degli utenti
* [Sicurezza](/developers/backend/resources/entities/security): configura regole di sicurezza a livello di riga per le entità
* [Struttura del progetto](/developers/backend/overview/project-structure): come gli schemi delle entità si inseriscono nel tuo progetto

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