Passer au contenu principal
Les applications Twenty sont des packages TypeScript qui étendent votre espace de travail avec des objets personnalisés, de la logique, des composants d’interface utilisateur et des capacités d’IA. Elles s’exécutent sur la plateforme Twenty avec une isolation complète en bac à sable et des contrôles d’autorisations.

​
Fonctionnement des applications

Une application est un ensemble d’entités déclarées à l’aide des fonctions defineEntity() du package twenty-sdk. Le SDK détecte ces déclarations via une analyse de l’AST au moment de la compilation et produit un manifeste — une description complète de ce que votre application ajoute à un espace de travail. Ces fonctions valident votre configuration au moment de la compilation et offrent l’autocomplétion dans l’IDE et une sécurité de typage. 
your-app/
├── src/
│   ├── application-config.ts    ← defineApplication (required, one per app)
│   ├── roles/                   ← defineRole
│   ├── objects/                 ← defineObject
│   ├── fields/                  ← defineField
│   ├── logic-functions/         ← defineLogicFunction
│   ├── front-components/        ← defineFrontComponent
│   ├── skills/                  ← defineSkill
│   ├── agents/                  ← defineAgent
│   ├── views/                   ← defineView
│   ├── navigation-menu-items/   ← defineNavigationMenuItem
│   └── page-layouts/            ← definePageLayout
├── public/                      ← Static assets (images, icons)
└── package.json
L’organisation des fichiers vous revient. La détection des entités est basée sur l’AST — le SDK trouve les appels à export default defineEntity(...) quel que soit l’emplacement du fichier. La structure de dossiers ci-dessus est une convention, pas une obligation.

​
Types d’entités

EntitéObjectifDocumentation
ApplicationIdentité de l’application, rôle par défaut, variablesConfiguration de l’application
RôleEnsembles d’autorisations pour les objets et les champsRôles et autorisations
ObjetTypes d’enregistrements personnalisés avec des champsObjets
ChampAjouter des champs à des objets provenant d’autres applicationsExtension des objets
RelationLiens bidirectionnels entre les objetsRelations
Fonction logiqueTypeScript côté serveur avec des déclencheursFonctions logiques
CompétenceInstructions réutilisables pour des agents d’IACompétences et agents
AgentAssistants d’IA avec des prompts personnalisésCompétences et agents
Fournisseur de connexionIdentifiants OAuth pour les API tiercesConnexions
VueVues de liste d’enregistrements préconfiguréesVues
Élément de menu de navigationEntrées personnalisées de la barre latéraleÉléments du menu de navigation
Mise en pageOnglets et widgets sur la page de détails d’un enregistrementMises en page
Composant frontalInterface React isolée en bac à sable dans TwentyComposants frontaux
Élément du menu de commandeActions rapides et entrées Cmd+KÉléments du menu de commande

​
Exécution en bac à sable

  • Les fonctions logiques s’exécutent dans des processus Node.js isolés sur le serveur. Elles n’accèdent aux données qu’au moyen du client d’API typé, limité par les autorisations du rôle de l’application.
  • Les composants frontaux s’exécutent dans des Web Workers en utilisant Remote DOM — isolés en bac à sable de la page principale mais rendant des éléments DOM natifs (pas d’iframes). Ils communiquent avec Twenty via une API hôte de passage de messages.
  • Les autorisations sont appliquées au niveau de l’API. Le jeton d’exécution (TWENTY_APP_ACCESS_TOKEN) est dérivé du rôle défini dans defineApplication().

​
Cycle de vie de l’application

┌─────────────────────────────────────────────────────────┐
│ Development                                             │
│   npx create-twenty-app → yarn twenty dev (live sync)   │
├─────────────────────────────────────────────────────────┤
│ Build & Deploy                                          │
│   yarn twenty dev:build → yarn twenty app:publish        │
├─────────────────────────────────────────────────────────┤
│ Install flow                                            │
│   upload → [pre-install] → metadata migration →         │
│   generate SDK → [post-install]                         │
├─────────────────────────────────────────────────────────┤
│ Publish                                                 │
│   npm publish → appears in Twenty marketplace           │
└─────────────────────────────────────────────────────────┘
  • yarn twenty dev — surveille vos fichiers source et synchronise en direct les modifications avec un serveur Twenty connecté. Le client d’API typé est régénéré automatiquement lorsque le schéma change.
  • yarn twenty dev:build — compile TypeScript, regroupe les fonctions logiques et les composants frontaux avec esbuild, et produit un manifeste.
  • Hooks pré/post-install — fonctions optionnelles qui s’exécutent pendant l’installation. Voir Install Hooks pour plus de détails.

​
Prochaines étapes

Configuration

Identité de l’application, rôle par défaut et hooks d’installation.

Données

Objets, champs et relations bidirectionnelles.

Logique

Fonctions logiques, compétences, agents et connexions OAuth.

Disposition

Vues, navigation, mises en page, composants front-end.

Opérations

CLI, tests, dépôts distants, CI et publication de votre application.