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

# Schemas de Entidade

> Defina estruturas de dados customizadas usando um JSON Schema com regras de validação e tipos de campo

<div className="dev-docs-banner">
  <div className="dev-docs-banner-content">
    <div className="dev-docs-banner-title">
      Você está vendo a documentação para desenvolvedores
    </div>

    <div className="dev-docs-banner-text">
      Esta documentação é para desenvolvedores que trabalham com a plataforma para desenvolvedores Base44. Para informações sobre como gerenciar os dados do seu app usando o editor de apps, veja <a href="/Building-your-app/Managing-your-app-data">Gerenciar dados do app</a>.
    </div>
  </div>
</div>

As entidades são definidas usando um JSON Schema que descreve a estrutura dos dados e as regras de validação.

## Estrutura básica do schema

Schemas de entidade são definidos em arquivos JSON no diretório de entidades do seu projeto. Por padrão, este é `base44/entities/`, mas você pode personalizar o caminho na [configuração do seu projeto](/developers/backend/overview/project-structure#config-jsonc). O nome do arquivo determina o nome da entidade. Por exemplo, `Task.json` cria uma entidade `Task`.

Aqui está um template de schema de entidade:

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

## Campos integrados

Cada registro de entidade inclui automaticamente os seguintes campos. Não defina campos com esses nomes no seu schema.

| Campo                    | Tipo     | Descrição                                        |
| ------------------------ | -------- | ------------------------------------------------ |
| `id`                     | string   | Identificador único do registro                  |
| `created_date`           | datetime | Quando o registro foi criado                     |
| `updated_date`           | datetime | Quando o registro foi atualizado pela última vez |
| `created_by`             | string   | E-mail do usuário que criou o registro           |
| `created_by_id`          | string   | ID do usuário que criou o registro               |
| `is_deleted` (interno)   | boolean  | Flag de soft delete                              |
| `deleted_date` (interno) | datetime | Quando o registro foi excluído                   |
| `is_sample` (interno)    | boolean  | Se o registro é dado de amostra                  |
| `entity_name` (interno)  | string   | Nome do tipo de entidade                         |
| `app_id` (interno)       | string   | ID do app                                        |
| `environment` (interno)  | string   | Ou `prod` ou `dev`                               |

Campos internos não são retornados nas respostas da API, mas podem ser referenciados em [regras de segurança](/developers/backend/resources/entities/security).

## Campos do schema

<ResponseField name="name" type="string">
  Identificador em string para a entidade.
</ResponseField>

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

<ResponseField name="title" type="string">
  Nome de exibição amigável ao usuário.
</ResponseField>

<ResponseField name="description" type="string">
  Descrição do que a entidade representa.
</ResponseField>

<ResponseField name="properties" type="object" required>
  Objeto contendo suas definições de campo. Cada campo tem um `type` e regras de
  validação opcionais.
</ResponseField>

## Tipos de campo

As entidades suportam vários tipos de campo para definir diferentes tipos de dados que você pode armazenar: `string`, `integer`, `number`, `boolean`, `array` e `object`.
Cada campo dentro de `properties` requer um `type`. Com base no tipo, você pode adicionar opções de validação.

### Campos string

Campos string suportam estas opções:

* **`minLength`** / **`maxLength`**: Controla a contagem mínima e máxima de caracteres.
* **`pattern`**: Expressão regular para validação customizada.
* **`format`**: Formatos predefinidos. Valores suportados:
  * `"date"`
  * `"date-time"`
  * `"time"`
  * `"email"`
  * `"uri"`
  * `"hostname"`
  * `"ipv4"`
  * `"ipv6"`
  * `"uuid"`
* **`enum`**: Restrição a valores permitidos específicos. Defina como um array: `["value1", "value2", "value3"]`.
* **`default`**: Valor padrão se nenhum for fornecido.

### Campos integer

Campos integer suportam estas opções:

* **`minimum`** / **`maximum`**: Define limites inferior/superior inclusivos.
* **`default`**: Valor padrão se nenhum for fornecido.

### Campos number

Campos number suportam estas opções:

* **`minimum`** / **`maximum`**: Define limites inferior/superior inclusivos.
* **`default`**: Valor padrão se nenhum for fornecido.

### Campos boolean

Campos boolean suportam estas opções:

* **`default`**: Valor padrão se nenhum for fornecido.

### Campos array

Campos array suportam estas opções:

* **`items`**: Define o tipo/schema para elementos do array.
* **`default`**: Valor padrão do array se nenhum for fornecido.

### Campos object

Campos object suportam estas opções:

* **`properties`**: Define os campos dentro do objeto.
* **`required`**: Lista de nomes de propriedade obrigatórios.

## Campos obrigatórios

Especifique quais campos devem ser fornecidos:

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

## Exemplo completo

Aqui está um schema de entidade 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}}"}
  }
}
```

## Implantando entidades

Após definir seu schema de entidade, implante-o na Base44 usando [`entities push`](/developers/references/cli/commands/entities-push). As entidades também são implantadas automaticamente quando você executa o comando [`deploy`](/developers/references/cli/commands/deploy) para implantar todo o seu projeto.

Uma vez implantadas, você pode interagir com suas entidades usando o [módulo `entities` do SDK](/developers/references/sdk/docs/type-aliases/entities). O nome da entidade no seu schema deve corresponder exatamente a como você a acessa no SDK, incluindo capitalização. Por exemplo, se seu schema tem `"name": "Task"`, você deve acessá-la como `base44.entities.Task.list()`.

Schemas de entidade implantados podem ser visualizados no dashboard na seção **Data**.

## Veja também

* [User Schema](/developers/backend/resources/entities/user-schema): Entidade integrada especial para autenticação de usuário
* [Segurança](/developers/backend/resources/entities/security): Configure regras de segurança em nível de linha para entidades
* [Estrutura do projeto](/developers/backend/overview/project-structure): Como schemas de entidade se encaixam no seu projeto

<Note>Esta página foi traduzida usando IA. Para informações mais precisas e atualizadas, consulte a [versão em inglês](/). </Note>