i18n - docs translations (#18280)

Created by Github action --------- Co-authored-by: github-actions <github-actions@twenty.com>
2026-02-27 23:12:39 +01:00
parent c0e6aa1c0b
commit 9f5a8735c9
46 changed files with 619 additions and 617 deletions
@@ -6,9 +6,9 @@ Dieses Dokument beschreibt die besten Praktiken, die Sie beim Arbeiten am Fronte

 ## Zustandsverwaltung

-React and Jotai handle state management in the codebase.
+React und Jotai übernehmen die Zustandsverwaltung im Code.

-### Use Jotai atoms to store state
+### Verwenden Sie Jotai-Atome, um den Zustand zu speichern

 Es ist eine gute Praxis, so viele Atome zu erstellen, wie Sie benötigen, um Ihren Zustand zu speichern.

@@ -45,7 +45,7 @@ export const MyComponent = () => {

 Vermeiden Sie die Verwendung von `useRef`, um den Zustand zu speichern.

-If you want to store state, you should use `useState` or Jotai atoms with `useAtomState`.
+Wenn Sie den Zustand speichern möchten, sollten Sie `useState` oder Jotai-Atome mit `useAtomState` verwenden.

 Sehen Sie sich [an, wie Re-Renderings verwaltet werden können](#managing-re-renders), falls Sie das Gefühl haben, dass Sie `useRef` benötigen, um einige Re-Renderings zu verhindern.

@@ -82,8 +82,8 @@ If you feel like you need to add a `useEffect` in your root component, you shoul
 Dasselbe können Sie auch für die Datenabruflogik mit Apollo-Hooks anwenden.

 ```tsx
-// ❌ Bad, will cause re-renders even if data is not changing,
-//    because useEffect needs to be re-evaluated
+// ❌ Schlecht, verursacht Re-Renders, auch wenn sich die Daten nicht ändern,
+//    weil useEffect neu ausgewertet werden muss
 export const PageComponent = () => {
  const [data, setData] = useAtomState(dataState);
  const [someDependency] = useAtomState(someDependencyState);
@@ -103,8 +103,8 @@ export const App = () => (
 ```

 ```tsx
-// ✅ Good, will not cause re-renders if data is not changing,
-//   because useEffect is re-evaluated in another sibling component
+// ✅ Gut, verursacht keine Re-Renders, wenn sich die Daten nicht ändern,
+//   weil useEffect in einer anderen Geschwisterkomponente neu ausgewertet wird
 export const PageComponent = () => {
  const [data, setData] = useAtomState(dataState);

@@ -132,9 +132,9 @@ export const App = () => (
 );
 ```

-### Use atom family states and selectors
+### Verwenden Sie Atom-Familienzustände und Selektoren

-Atom family states and selectors are a great way to avoid re-renders.
+Atom-Familienzustände und Selektoren sind eine großartige Möglichkeit, Re-Renders zu vermeiden.

 Sie sind nützlich, wenn Sie eine Liste von Elementen speichern müssen.

@@ -77,7 +77,7 @@ To avoid unnecessary [re-renders](/l/de/developers/contribute/capabilities/front

 ### Zustandsverwaltung

-[Jotai](https://jotai.org/) handles state management.
+[Jotai](https://jotai.org/) übernimmt die Zustandsverwaltung.

 Siehe [Best Practices](/l/de/developers/contribute/capabilities/frontend-development/best-practices-front#state-management) für mehr Informationen zur Zustandsverwaltung.

@@ -160,7 +160,7 @@ export enum PageHotkeyScope {
 }
 ```

-Internally, the currently selected scope is stored in a Jotai atom that is shared across the application :
+Intern wird der aktuell ausgewählte Bereich in einem Jotai-Atom gespeichert, das in der gesamten Anwendung geteilt wird:

 ```tsx
 export const currentHotkeyScopeState = createState<HotkeyScope>({
@@ -169,10 +169,10 @@ export const currentHotkeyScopeState = createState<HotkeyScope>({
 });
 ```

-But this atom should never be handled manually ! Wir werden im nächsten Abschnitt sehen, wie man es verwendet.
+Aber dieses Atom sollte niemals manuell bearbeitet werden! Wir werden im nächsten Abschnitt sehen, wie man es verwendet.

 ## Wie funktioniert es intern?

 Wir haben eine dünne Schicht über [react-hotkeys-hook](https://react-hotkeys-hook.vercel.app/docs/intro) erstellt, die es leistungsfähiger macht und unnötige Neu-Renderings vermeidet.

-We also create a Jotai atom to handle the hotkey scope state and make it available everywhere in the application.
+Wir erstellen außerdem ein Jotai-Atom, um den Zustand des Tastenkombinationsbereichs zu verwalten und in der gesamten Anwendung verfügbar zu machen.
@@ -52,26 +52,26 @@ npx create-twenty-app@latest my-app --interactive
 Von hier aus können Sie:

 ```bash filename="Terminal"
-# Add a new entity to your application (guided)
+# Eine neue Entität zu Ihrer Anwendung hinzufügen (geführt)
 yarn twenty entity:add

-# Watch your application's function logs
+# Die Funktionsprotokolle Ihrer Anwendung überwachen
 yarn twenty function:logs

-# Execute a function by name
+# Eine Funktion anhand ihres Namens ausführen
 yarn twenty function:execute -n my-function -p '{"name": "test"}'

-# Execute the pre-install function
+# Die Pre-Installationsfunktion ausführen
 yarn twenty function:execute --preInstall

-# Execute the post-install function
+# Die Post-Installationsfunktion ausführen
 yarn twenty function:execute --postInstall

-# Uninstall the application from the current workspace
+# Die Anwendung aus dem aktuellen Arbeitsbereich deinstallieren
 yarn twenty app:uninstall

-# Display commands' help
-yarn twenty help
+# Hilfe zu Befehlen anzeigen
+yarn twenty help},{
 ```

 Siehe auch: die CLI-Referenzseiten für [create-twenty-app](https://www.npmjs.com/package/create-twenty-app) und [twenty-sdk CLI](https://www.npmjs.com/package/twenty-sdk).
@@ -83,7 +83,7 @@ Wenn Sie `npx create-twenty-app@latest my-twenty-app` ausführen, erledigt der S
 * Kopiert eine minimale Basisanwendung nach `my-twenty-app/`
 * Fügt eine lokale `twenty-sdk`-Abhängigkeit und die Yarn-4-Konfiguration hinzu
 * Erstellt Konfigurationsdateien und Skripte, die an die `twenty`-CLI angebunden sind
-* Generates core files (application config, default function role, pre-install and post-install functions) plus example files based on the scaffolding mode
+* Erzeugt Kerndateien (Anwendungskonfiguration, Standardrolle für Logikfunktionen, Pre-Installations- und Post-Installationsfunktionen) sowie Beispieldateien entsprechend dem Scaffolding-Modus

 Eine frisch erstellte App mit dem Standardmodus `--exhaustive` sieht so aus:

@@ -99,30 +99,30 @@ my-twenty-app/
  eslint.config.mjs
  tsconfig.json
  README.md
-  public/                           # Public assets folder (images, fonts, etc.)
+  public/                           # Ordner für öffentliche Assets (Bilder, Schriftarten usw.)
  src/
-  ├── application-config.ts           # Required - main application configuration
+  ├── application-config.ts           # Erforderlich - Hauptkonfiguration der Anwendung
  ├── roles/
-  │   └── default-role.ts               # Default role for logic functions
+  │   └── default-role.ts               # Standardrolle für Logikfunktionen
  ├── objects/
-  │   └── example-object.ts             # Example custom object definition
+  │   └── example-object.ts             # Beispiel für eine benutzerdefinierte Objektdefinition
  ├── fields/
-  │   └── example-field.ts              # Example standalone field definition
+  │   └── example-field.ts              # Beispiel für eine eigenständige Felddefinition
  ├── logic-functions/
-  │   ├── hello-world.ts                # Example logic function
-  │   ├── pre-install.ts                # Pre-install logic function
-  │   └── post-install.ts               # Post-install logic function
+  │   ├── hello-world.ts                # Beispiel für eine Logikfunktion
+  │   ├── pre-install.ts                # Pre-Installations-Logikfunktion
+  │   └── post-install.ts               # Post-Installations-Logikfunktion
  ├── front-components/
-  │   └── hello-world.tsx               # Example front component
+  │   └── hello-world.tsx               # Beispiel für eine Frontend-Komponente
  ├── views/
-  │   └── example-view.ts                # Example saved view definition
+  │   └── example-view.ts                # Beispiel für eine gespeicherte View-Definition
  ├── navigation-menu-items/
-  │   └── example-navigation-menu-item.ts # Example sidebar navigation link
+  │   └── example-navigation-menu-item.ts # Beispiel für einen Navigationslink in der Seitenleiste
  └── skills/
-      └── example-skill.ts                # Example AI agent skill definition
+      └── example-skill.ts                # Beispiel für eine Skill-Definition eines KI-Agenten
 ```

-With `--minimal`, only the core files are created (`application-config.ts`, `roles/default-role.ts`, `logic-functions/pre-install.ts`, and `logic-functions/post-install.ts`). Mit `--interactive` wählst du aus, welche Beispieldateien enthalten sein sollen.
+Mit `--minimal` werden nur die Kerndateien erstellt (`application-config.ts`, `roles/default-role.ts`, `logic-functions/pre-install.ts` und `logic-functions/post-install.ts`). Mit `--interactive` wählst du aus, welche Beispieldateien enthalten sein sollen.

 Auf hoher Ebene:

@@ -139,18 +139,18 @@ Auf hoher Ebene:

 Das SDK erkennt Entitäten, indem es Ihre TypeScript-Dateien nach Aufrufen von **`export default define<Entity>({...})`** parst. Für jeden Entitätstyp gibt es eine entsprechende Hilfsfunktion, die aus `twenty-sdk` exportiert wird:

-| Hilfsfunktion                      | Entitätstyp                                           |
-| ---------------------------------- | ----------------------------------------------------- |
-| `defineObject()`                   | Benutzerdefinierte Objektdefinitionen                 |
-| `defineLogicFunction()`            | Definitionen von Logikfunktionen                      |
-| `definePreInstallLogicFunction()`  | Pre-install logic function (runs before installation) |
-| `definePostInstallLogicFunction()` | Post-install logic function (runs after installation) |
-| `defineFrontComponent()`           | Definitionen von Frontend-Komponenten                 |
-| `defineRole()`                     | Rollendefinitionen                                    |
-| `defineField()`                    | Felderweiterungen für bestehende Objekte              |
-| `defineView()`                     | Gespeicherte View-Definitionen                        |
-| `defineNavigationMenuItem()`       | Definitionen von Navigationsmenüeinträgen             |
-| `defineSkill()`                    | Skill-Definitionen für KI-Agenten                     |
+| Hilfsfunktion                      | Entitätstyp                                                              |
+| ---------------------------------- | ------------------------------------------------------------------------ |
+| `defineObject()`                   | Benutzerdefinierte Objektdefinitionen                                    |
+| `defineLogicFunction()`            | Definitionen von Logikfunktionen                                         |
+| `definePreInstallLogicFunction()`  | Pre-Installations-Logikfunktion (wird vor der Installation ausgeführt)   |
+| `definePostInstallLogicFunction()` | Post-Installations-Logikfunktion (wird nach der Installation ausgeführt) |
+| `defineFrontComponent()`           | Definitionen von Frontend-Komponenten                                    |
+| `defineRole()`                     | Rollendefinitionen                                                       |
+| `defineField()`                    | Felderweiterungen für bestehende Objekte                                 |
+| `defineView()`                     | Gespeicherte View-Definitionen                                           |
+| `defineNavigationMenuItem()`       | Definitionen von Navigationsmenüeinträgen                                |
+| `defineSkill()`                    | Skill-Definitionen für KI-Agenten                                        |

 <Note>
 **Dateibenennung ist flexibel.** Die Entitätserkennung ist AST-basiert — das SDK durchsucht Ihre Quelldateien nach dem Muster `export default define<Entity>({...})`. Sie können Ihre Dateien und Ordner nach Belieben organisieren. Die Gruppierung nach Entitätstyp (z. B. `logic-functions/`, `roles/`) ist lediglich eine Konvention zur Codeorganisation, keine Voraussetzung.
@@ -215,19 +215,19 @@ Das twenty-sdk stellt typisierte Bausteine und Hilfsfunktionen bereit, die Sie i

 Das SDK stellt Hilfsfunktionen bereit, um die Entitäten Ihrer App zu definieren. Wie in [Entitätserkennung](#entity-detection) beschrieben, müssen Sie `export default define<Entity>({...})` verwenden, damit Ihre Entitäten erkannt werden:

-| Funktion                           | Zweck                                                          |
-| ---------------------------------- | -------------------------------------------------------------- |
-| `defineApplication()`              | Anwendungsmetadaten konfigurieren (erforderlich, eine pro App) |
-| `defineObject()`                   | Benutzerdefinierte Objekte mit Feldern definieren              |
-| `defineLogicFunction()`            | Logikfunktionen mit Handlern definieren                        |
-| `definePreInstallLogicFunction()`  | Define a pre-install logic function (one per app)              |
-| `definePostInstallLogicFunction()` | Define a post-install logic function (one per app)             |
-| `defineFrontComponent()`           | Frontend-Komponenten für benutzerdefinierte UI definieren      |
-| `defineRole()`                     | Rollenberechtigungen und Objektzugriff konfigurieren           |
-| `defineField()`                    | Bestehende Objekte mit zusätzlichen Feldern erweitern          |
-| `defineView()`                     | Gespeicherte Views für Objekte definieren                      |
-| `defineNavigationMenuItem()`       | Seitenleisten-Navigationslinks definieren                      |
-| `defineSkill()`                    | Definieren Sie Skills für KI-Agenten                           |
+| Funktion                           | Zweck                                                           |
+| ---------------------------------- | --------------------------------------------------------------- |
+| `defineApplication()`              | Anwendungsmetadaten konfigurieren (erforderlich, eine pro App)  |
+| `defineObject()`                   | Benutzerdefinierte Objekte mit Feldern definieren               |
+| `defineLogicFunction()`            | Logikfunktionen mit Handlern definieren                         |
+| `definePreInstallLogicFunction()`  | Eine Pre-Installations-Logikfunktion definieren (eine pro App)  |
+| `definePostInstallLogicFunction()` | Eine Post-Installations-Logikfunktion definieren (eine pro App) |
+| `defineFrontComponent()`           | Frontend-Komponenten für benutzerdefinierte UI definieren       |
+| `defineRole()`                     | Rollenberechtigungen und Objektzugriff konfigurieren            |
+| `defineField()`                    | Bestehende Objekte mit zusätzlichen Feldern erweitern           |
+| `defineView()`                     | Gespeicherte Views für Objekte definieren                       |
+| `defineNavigationMenuItem()`       | Seitenleisten-Navigationslinks definieren                       |
+| `defineSkill()`                    | Definieren Sie Skills für KI-Agenten                            |

 Diese Funktionen validieren Ihre Konfiguration zur Build-Zeit und bieten IDE-Autovervollständigung sowie Typsicherheit.

@@ -327,7 +327,7 @@ Jede App hat eine einzelne Datei `application-config.ts`, die Folgendes beschrei
 * **Was die App ist**: Bezeichner, Anzeigename und Beschreibung.
 * **Wie ihre Funktionen ausgeführt werden**: welche Rolle sie für Berechtigungen verwenden.
 * **(Optional) Variablen**: Schlüssel–Wert-Paare, die Ihren Funktionen als Umgebungsvariablen zur Verfügung gestellt werden.
-* **(Optional) pre-install function**: a logic function that runs before the app is installed.
+* **(Optional) Pre-Installationsfunktion**: eine Logikfunktion, die vor der Installation der App ausgeführt wird.
 * **(Optional) Post-Installationsfunktion**: eine Logikfunktion, die nach der Installation der App ausgeführt wird.

 Verwenden Sie `defineApplication()`, um Ihre Anwendungskonfiguration zu definieren:
@@ -359,7 +359,7 @@ Notizen:
 * `universalIdentifier`-Felder sind deterministische IDs, die Sie besitzen; generieren Sie sie einmal und halten Sie sie über Synchronisierungen hinweg stabil.
 * `applicationVariables` werden zu Umgebungsvariablen für Ihre Funktionen (zum Beispiel ist `DEFAULT_RECIPIENT_NAME` als `process.env.DEFAULT_RECIPIENT_NAME` verfügbar).
 * `defaultRoleUniversalIdentifier` muss mit der Rollendatei übereinstimmen (siehe unten).
-* Pre-install and post-install functions are automatically detected during the manifest build. See [Pre-install functions](#pre-install-functions) and [Post-install functions](#post-install-functions).
+* Pre-Installations- und Post-Installationsfunktionen werden während des Manifest-Builds automatisch erkannt. Siehe [Pre-Installationsfunktionen](#pre-install-functions) und [Post-Installationsfunktionen](#post-install-functions).

 #### Rollen und Berechtigungen

@@ -498,11 +498,11 @@ Notizen:
 * Das Array `triggers` ist optional. Funktionen ohne Trigger können als von anderen Funktionen aufgerufene Utility-Funktionen verwendet werden.
 * Sie können mehrere Trigger-Typen in einer Funktion kombinieren.

-### Pre-install functions
+### Pre-Installationsfunktionen

-A pre-install function is a logic function that runs automatically before your app is installed on a workspace. This is useful for validation tasks, prerequisite checks, or preparing workspace state before the main installation proceeds.
+Eine Pre-Installationsfunktion ist eine Logikfunktion, die automatisch ausgeführt wird, bevor deine App in einem Arbeitsbereich installiert wird. Dies ist nützlich für Validierungsaufgaben, Überprüfungen von Voraussetzungen oder die Vorbereitung des Status des Arbeitsbereichs, bevor die Hauptinstallation fortgesetzt wird.

-When you scaffold a new app with `create-twenty-app`, a pre-install function is generated for you at `src/logic-functions/pre-install.ts`:
+Wenn du mit `create-twenty-app` eine neue App erstellst, wird für dich eine Pre-Installationsfunktion unter `src/logic-functions/pre-install.ts` erzeugt:

 ```typescript
 // src/logic-functions/pre-install.ts
@@ -521,7 +521,7 @@ export default definePreInstallLogicFunction({
 });
 ```

-You can also manually execute the pre-install function at any time using the CLI:
+Du kannst die Pre-Installationsfunktion auch jederzeit manuell über die CLI ausführen:

 ```bash filename="Terminal"
 yarn twenty function:execute --preInstall
@@ -529,12 +529,12 @@ yarn twenty function:execute --preInstall

 Hauptpunkte:

-* Pre-install functions use `definePreInstallLogicFunction()` — a specialized variant that omits trigger settings (`cronTriggerSettings`, `databaseEventTriggerSettings`, `httpRouteTriggerSettings`, `isTool`).
-* The handler receives an `InstallLogicFunctionPayload` with `{ previousVersion: string }` — the version of the app that was previously installed (or an empty string for fresh installs).
-* Only one pre-install function is allowed per application. The manifest build will error if more than one is detected.
-* The function's `universalIdentifier` is automatically set as `preInstallLogicFunctionUniversalIdentifier` on the application manifest during the build — you do not need to reference it in `defineApplication()`.
-* The default timeout is set to 300 seconds (5 minutes) to allow for longer preparation tasks.
-* Pre-install functions do not need triggers — they are invoked by the platform before installation or manually via `function:execute --preInstall`.
+* Pre-Installationsfunktionen verwenden `definePreInstallLogicFunction()` — eine spezialisierte Variante, die Trigger-Einstellungen (`cronTriggerSettings`, `databaseEventTriggerSettings`, `httpRouteTriggerSettings`, `isTool`) weglässt.
+* Der Handler erhält ein `InstallLogicFunctionPayload` mit `{ previousVersion: string }` — die Version der App, die zuvor installiert war (oder eine leere Zeichenkette bei Neuinstallationen).
+* Pro Anwendung ist nur eine Pre-Installationsfunktion zulässig. Der Manifest-Build schlägt fehl, wenn mehr als eine erkannt wird.
+* Der `universalIdentifier` der Funktion wird während des Builds im Anwendungsmanifest automatisch als `preInstallLogicFunctionUniversalIdentifier` gesetzt — du musst ihn nicht in `defineApplication()` referenzieren.
+* Das standardmäßige Timeout ist auf 300 Sekunden (5 Minuten) festgelegt, um längere Vorbereitungsvorgänge zu ermöglichen.
+* Pre-Installationsfunktionen benötigen keine Trigger — sie werden von der Plattform vor der Installation oder manuell über `function:execute --preInstall` aufgerufen.

 ### Post-Installationsfunktionen

@@ -567,10 +567,10 @@ yarn twenty function:execute --postInstall

 Hauptpunkte:

-* Post-install functions use `definePostInstallLogicFunction()` — a specialized variant that omits trigger settings (`cronTriggerSettings`, `databaseEventTriggerSettings`, `httpRouteTriggerSettings`, `isTool`).
-* The handler receives an `InstallLogicFunctionPayload` with `{ previousVersion: string }` — the version of the app that was previously installed (or an empty string for fresh installs).
-* Only one post-install function is allowed per application. The manifest build will error if more than one is detected.
-* The function's `universalIdentifier` is automatically set as `postInstallLogicFunctionUniversalIdentifier` on the application manifest during the build — you do not need to reference it in `defineApplication()`.
+* Post-Installationsfunktionen verwenden `definePostInstallLogicFunction()` — eine spezialisierte Variante, die Trigger-Einstellungen (`cronTriggerSettings`, `databaseEventTriggerSettings`, `httpRouteTriggerSettings`, `isTool`) weglässt.
+* Der Handler erhält ein `InstallLogicFunctionPayload` mit `{ previousVersion: string }` — die Version der App, die zuvor installiert war (oder eine leere Zeichenkette bei Neuinstallationen).
+* Pro Anwendung ist nur eine Post-Installationsfunktion zulässig. Der Manifest-Build schlägt fehl, wenn mehr als eine erkannt wird.
+* Der `universalIdentifier` der Funktion wird während des Builds im Anwendungsmanifest automatisch als `postInstallLogicFunctionUniversalIdentifier` gesetzt — du musst ihn nicht in `defineApplication()` referenzieren.
 * Das standardmäßige Timeout ist auf 300 Sekunden (5 Minuten) festgelegt, um längere Einrichtungsvorgänge wie Daten-Seeding zu ermöglichen.
 * Post-Installationsfunktionen benötigen keine Trigger — sie werden von der Plattform während der Installation oder manuell über `function:execute --postInstall` aufgerufen.