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

# Entity-Schemas

> Definiere eigene Datenstrukturen mit einem JSON-Schema, Validierungsregeln und Feldtypen

<div className="dev-docs-banner">
  <div className="dev-docs-banner-content">
    <div className="dev-docs-banner-title">
      Du siehst gerade die Entwicklerdokumentation
    </div>

    <div className="dev-docs-banner-text">
      Diese Dokumentation richtet sich an Entwickler, die mit der Base44-Entwicklerplattform arbeiten. Informationen zum Verwalten deiner App-Daten über den App-Editor findest du unter <a href="/Building-your-app/Managing-your-app-data">App-Daten verwalten</a>.
    </div>
  </div>
</div>

Entitäten werden mit einem JSON-Schema definiert, das die Datenstruktur und die Validierungsregeln beschreibt.

## Grundlegende Schema-Struktur

Entity-Schemas werden in JSON-Dateien im Entities-Verzeichnis deines Projekts definiert. Standardmäßig ist das `base44/entities/`, aber du kannst den Pfad in deiner [Projektkonfiguration](/developers/backend/overview/project-structure#config-jsonc) anpassen. Der Dateiname bestimmt den Entitätsnamen. Zum Beispiel erstellt `Task.json` eine `Task`-Entität.

Hier ist ein Schema-Template für eine Entität:

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

## Integrierte Felder

Jeder Entity-Datensatz enthält automatisch die folgenden Felder. Definiere in deinem Schema keine Felder mit diesen Namen.

| Feld                    | Typ      | Beschreibung                                         |
| ----------------------- | -------- | ---------------------------------------------------- |
| `id`                    | string   | Eindeutige Kennung für den Datensatz                 |
| `created_date`          | datetime | Wann der Datensatz erstellt wurde                    |
| `updated_date`          | datetime | Wann der Datensatz zuletzt aktualisiert wurde        |
| `created_by`            | string   | E-Mail des Benutzers, der den Datensatz erstellt hat |
| `created_by_id`         | string   | ID des Benutzers, der den Datensatz erstellt hat     |
| `is_deleted` (intern)   | boolean  | Soft-Delete-Flag                                     |
| `deleted_date` (intern) | datetime | Wann der Datensatz gelöscht wurde                    |
| `is_sample` (intern)    | boolean  | Ob der Datensatz Beispieldaten sind                  |
| `entity_name` (intern)  | string   | Name des Entitätstyps                                |
| `app_id` (intern)       | string   | App-ID                                               |
| `environment` (intern)  | string   | Entweder `prod` oder `dev`                           |

Interne Felder werden nicht in API-Antworten zurückgegeben, können aber in [Sicherheitsregeln](/developers/backend/resources/entities/security) referenziert werden.

## Schema-Felder

<ResponseField name="name" type="string">
  String-Identifier für die Entität.
</ResponseField>

<ResponseField name="type" type="string" required>
  Muss `"object"` sein.
</ResponseField>

<ResponseField name="title" type="string">
  Benutzerfreundlicher Anzeigename.
</ResponseField>

<ResponseField name="description" type="string">
  Beschreibung dessen, was die Entität darstellt.
</ResponseField>

<ResponseField name="properties" type="object" required>
  Objekt, das deine Felddefinitionen enthält. Jedes Feld hat einen `type` und optionale
  Validierungsregeln.
</ResponseField>

## Feldtypen

Entitäten unterstützen verschiedene Feldtypen, um unterschiedliche Arten von Daten zu definieren, die du speichern kannst: `string`, `integer`, `number`, `boolean`, `array` und `object`.
Jedes Feld innerhalb von `properties` benötigt einen `type`. Je nach Typ kannst du Validierungsoptionen hinzufügen.

### String-Felder

String-Felder unterstützen diese Optionen:

* **`minLength`** / **`maxLength`**: Steuern die minimale und maximale Zeichenanzahl.
* **`pattern`**: Regulärer Ausdruck für eigene Validierung.
* **`format`**: Vordefinierte Formate. Unterstützte Werte:
  * `"date"`
  * `"date-time"`
  * `"time"`
  * `"email"`
  * `"uri"`
  * `"hostname"`
  * `"ipv4"`
  * `"ipv6"`
  * `"uuid"`
* **`enum`**: Beschränkt auf bestimmte erlaubte Werte. Als Array definieren: `["value1", "value2", "value3"]`.
* **`default`**: Standardwert, falls keiner angegeben wird.

### Integer-Felder

Integer-Felder unterstützen diese Optionen:

* **`minimum`** / **`maximum`**: Inklusive Unter-/Obergrenzen.
* **`default`**: Standardwert, falls keiner angegeben wird.

### Number-Felder

Number-Felder unterstützen diese Optionen:

* **`minimum`** / **`maximum`**: Inklusive Unter-/Obergrenzen.
* **`default`**: Standardwert, falls keiner angegeben wird.

### Boolean-Felder

Boolean-Felder unterstützen diese Optionen:

* **`default`**: Standardwert, falls keiner angegeben wird.

### Array-Felder

Array-Felder unterstützen diese Optionen:

* **`items`**: Definiert den Typ/das Schema der Array-Elemente.
* **`default`**: Standardwert für das Array, falls keiner angegeben wird.

### Object-Felder

Object-Felder unterstützen diese Optionen:

* **`properties`**: Definiert die Felder innerhalb des Objekts.
* **`required`**: Liste der erforderlichen Eigenschaftsnamen.

## Erforderliche Felder

Lege fest, welche Felder angegeben werden müssen:

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

## Vollständiges Beispiel

Hier ist ein vollständiges Entity-Schema:

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

## Entitäten deployen

Nachdem du dein Entity-Schema definiert hast, deploye es mit [`entities push`](/developers/references/cli/commands/entities-push) zu Base44. Entitäten werden außerdem automatisch deployed, wenn du den [`deploy`](/developers/references/cli/commands/deploy)-Befehl ausführst, um dein gesamtes Projekt zu deployen.

Sobald deployed, kannst du mit deinen Entitäten über das [`entities`-Modul des SDK](/developers/references/sdk/docs/type-aliases/entities) interagieren. Der Entitätsname in deinem Schema muss exakt mit dem übereinstimmen, wie du im SDK darauf zugreifst, einschließlich Groß- und Kleinschreibung. Wenn dein Schema z. B. `"name": "Task"` hat, musst du es als `base44.entities.Task.list()` ansprechen.

Deployed Entity-Schemas können im Dashboard im Bereich **Data** eingesehen werden.

## Siehe auch

* [User-Schema](/developers/backend/resources/entities/user-schema): Spezielle eingebaute Entität für Benutzer-Authentifizierung
* [Sicherheit](/developers/backend/resources/entities/security): Konfiguriere Row-Level-Security-Regeln für Entitäten
* [Projektstruktur](/developers/backend/overview/project-structure): Wie Entity-Schemas in dein Projekt passen

<Note>Diese Seite wurde mit KI übersetzt. Für die genauesten und aktuellsten Informationen siehe die [englische Version](/). </Note>