diff --git a/packages/twenty-docs/l/ar/developers/extend/capabilities/apps.mdx b/packages/twenty-docs/l/ar/developers/extend/capabilities/apps.mdx index b1e87ab08b..18b04922a2 100644 --- a/packages/twenty-docs/l/ar/developers/extend/capabilities/apps.mdx +++ b/packages/twenty-docs/l/ar/developers/extend/capabilities/apps.mdx @@ -89,20 +89,20 @@ my-twenty-app/ eslint.config.mjs tsconfig.json README.md - public/ # Public assets folder (images, fonts, etc.) + public/ # مجلد الأصول العامة (صور، خطوط، إلخ) src/ - ├── application-config.ts # Required - main application configuration + ├── application-config.ts # مطلوب - التكوين الرئيسي للتطبيق ├── roles/ - │ └── default-role.ts # Default role for logic functions + │ └── default-role.ts # الدور الافتراضي لوظائف المنطق ├── logic-functions/ - │ └── hello-world.ts # Example logic function + │ └── hello-world.ts # مثال لوظيفة منطقية └── front-components/ - └── hello-world.tsx # Example front component + └── hello-world.tsx # مثال لمكوّن الواجهة الأمامية ``` بشكل عام: -* **package.json**: Declares the app name, version, engines (Node 24+, Yarn 4), and adds `twenty-sdk` plus scripts like `app:dev`, `app:generate`, `entity:add`, `function:logs`, `function:execute`, `app:uninstall`, and authentication commands that delegate to the local `twenty` CLI. +* **package.json**: يصرّح باسم التطبيق والإصدار والمحرّكات (Node 24+، Yarn 4)، ويضيف `twenty-sdk` فضلًا عن نصوص مثل `app:dev` و`app:generate` و`entity:add` و`function:logs` و`function:execute` و`app:uninstall` وأوامر المصادقة التي تُفوِّض إلى `twenty` CLI المحلي. * **.gitignore**: يتجاهل العناصر الشائعة مثل `node_modules` و`.yarn` و`generated/` (عميل مضبوط الأنواع) و`dist/` و`build/` ومجلدات التغطية وملفات السجلات وملفات `.env*`. * **yarn.lock**، **.yarnrc.yml**، **.yarn/**: تقوم بقفل وتكوين حزمة أدوات Yarn 4 المستخدمة في المشروع. * **.nvmrc**: يثبّت إصدار Node.js المتوقع للمشروع. @@ -111,23 +111,23 @@ my-twenty-app/ * **public/**: مجلد لتخزين الأصول العامة (صور، خطوط، ملفات ثابتة) التي سيتم تقديمها مع تطبيقك. الملفات الموضوعة هنا تُرفع أثناء المزامنة وتكون متاحة أثناء وقت التشغيل. * **src/**: المكان الرئيسي حيث تعرّف تطبيقك ككود -### Entity detection +### اكتشاف الكيانات -The SDK detects entities by parsing your TypeScript files for **`export default define({...})`** calls. Each entity type has a corresponding helper function exported from `twenty-sdk`: +يكتشف SDK الكيانات عبر تحليل ملفات TypeScript الخاصة بك بحثًا عن استدعاءات **`export default define({...})`**. يحتوي كل نوع كيان على دالة مساعدة مقابلة يتم تصديرها من `twenty-sdk`: -| Helper function | نوع الكيان | -| ------------------------ | ------------------------------------- | -| `defineObject()` | تعريفات كائنات مخصصة | -| `defineLogicFunction()` | Logic function definitions | -| `defineFrontComponent()` | Front component definitions | -| `defineRole()` | تعريفات الأدوار | -| `defineField()` | Field extensions for existing objects | +| دالة مساعدة | نوع الكيان | +| ------------------------ | --------------------------------- | +| `defineObject()` | تعريفات كائنات مخصصة | +| `defineLogicFunction()` | تعريفات الوظائف المنطقية | +| `defineFrontComponent()` | Front component definitions | +| `defineRole()` | تعريفات الأدوار | +| `defineField()` | امتدادات الحقول للكائنات الموجودة | - **File naming is flexible.** Entity detection is AST-based — the SDK scans your source files for the `export default define({...})` pattern. You can organize your files and folders however you like. Grouping by entity type (e.g., `logic-functions/`, `roles/`) is just a convention for code organization, not a requirement. + **تسمية الملفات مرنة.** يعتمد اكتشاف الكيانات على بنية الشجرة المجردة (AST) — إذ يقوم SDK بفحص ملفات المصدر لديك بحثًا عن النمط `export default define({...})`. يمكنك تنظيم ملفاتك ومجلداتك كيفما تشاء. التجميع حسب نوع الكيان (مثلًا، `logic-functions/` و`roles/`) هو مجرد عرف لتنظيم الشيفرة، وليس مطلبًا إلزاميًا. -Example of a detected entity: +مثال على كيان تم اكتشافه: ```typescript // This file can be named anything and placed anywhere in src/ @@ -184,18 +184,18 @@ Once you've switched workspaces with `auth:switch`, all subsequent commands will ### دوال مساعدة -The SDK provides helper functions for defining your app entities. As described in [Entity detection](#entity-detection), you must use `export default define({...})` for your entities to be detected: +يوفّر SDK دوالًا مساعدة لتعريف كيانات تطبيقك. كما هو موضح في [اكتشاف الكيانات](#entity-detection)، يجب استخدام `export default define({...})` كي يتم اكتشاف كياناتك: -| دالة | الغرض | -| ------------------------ | ------------------------------------------------------ | -| `defineApplication()` | Configure application metadata (required, one per app) | -| `defineObject()` | تعريف كائنات مخصصة مع حقول | -| `defineLogicFunction()` | تعريف وظائف منطقية مع معالجات | -| `defineFrontComponent()` | Define front components for custom UI | -| `defineRole()` | تهيئة صلاحيات الدور والوصول إلى الكائنات | -| `defineField()` | Extend existing objects with additional fields | +| دالة | الغرض | +| ------------------------ | ---------------------------------------------------- | +| `defineApplication()` | تهيئة بيانات التعريف للتطبيق (مطلوب، واحد لكل تطبيق) | +| `defineObject()` | تعريف كائنات مخصصة مع حقول | +| `defineLogicFunction()` | تعريف وظائف منطقية مع معالجات | +| `defineFrontComponent()` | عرِّف مكوّنات أمامية لواجهة مستخدم مخصّصة | +| `defineRole()` | تهيئة صلاحيات الدور والوصول إلى الكائنات | +| `defineField()` | وسّع الكائنات الموجودة بحقول إضافية | -These functions validate your configuration at build time and provide IDE autocompletion and type safety. +تتحقق هذه الدوال من تكوينك وقت البناء وتوفّر إكمالًا تلقائيًا في بيئة التطوير وأمان الأنواع. ### تعريف الكائنات @@ -318,11 +318,11 @@ export default defineApplication({ * حقول `universalIdentifier` هي معرّفات حتمية تخصك؛ أنشئها مرة واحدة واحتفظ بها ثابتة عبر عمليات المزامنة. * `applicationVariables` تصبح متغيرات بيئة لوظائفك (على سبيل المثال، `DEFAULT_RECIPIENT_NAME` متاح كـ `process.env.DEFAULT_RECIPIENT_NAME`). -* `defaultRoleUniversalIdentifier` must match the role file (see below). +* `defaultRoleUniversalIdentifier` يجب أن يطابق ملف الدور (انظر أدناه). #### الأدوار والصلاحيات -يمكن للتطبيقات تعريف أدوار تُغلّف الصلاحيات على كائنات وإجراءات مساحة العمل لديك. The field `defaultRoleUniversalIdentifier` in `application-config.ts` designates the default role used by your app's logic functions. +يمكن للتطبيقات تعريف أدوار تُغلّف الصلاحيات على كائنات وإجراءات مساحة العمل لديك. يعين الحقل `defaultRoleUniversalIdentifier` في `application-config.ts` الدور الافتراضي الذي تستخدمه وظائف المنطق في تطبيقك. * مفتاح واجهة البرمجة في وقت التشغيل المحقون باسم `TWENTY_API_KEY` مستمد من دور الوظيفة الافتراضي هذا. * سيُقيَّد العميل مضبوط الأنواع بالأذونات الممنوحة لذلك الدور. @@ -372,10 +372,10 @@ export default defineRole({ }); ``` -The `universalIdentifier` of this role is then referenced in `application-config.ts` as `defaultRoleUniversalIdentifier`. بعبارة أخرى: +يُشار بعد ذلك إلى `universalIdentifier` لهذا الدور في `application-config.ts` باسم `defaultRoleUniversalIdentifier`. بعبارة أخرى: * **\\*.role.ts** يحدد ما يمكن أن يفعله الدور الافتراضي للوظيفة. -* **application-config.ts** points to that role so your functions inherit its permissions. +* **application-config.ts** يشير إلى ذلك الدور بحيث ترث وظائفك أذوناته. الملاحظات: @@ -386,7 +386,7 @@ The `universalIdentifier` of this role is then referenced in `application-config ### تكوين الوظيفة المنطقية ونقطة الدخول -Each function file uses `defineLogicFunction()` to export a configuration with a handler and optional triggers. +كل ملف وظيفة يستخدم `defineLogicFunction()` لتصدير تكوين مع معالج ومشغّلات اختيارية. ```typescript // src/app/createPostCard.logic-function.ts @@ -551,12 +551,12 @@ const handler = async (event: RoutePayload) => { يمكنك إنشاء وظائف جديدة بطريقتين: -* **Scaffolded**: Run `yarn entity:add` and choose the option to add a new logic function. يُولّد هذا ملفًا مبدئيًا مع معالج وتكوين. -* **Manual**: Create a new `*.logic-function.ts` file and use `defineLogicFunction()`, following the same pattern. +* **مُنشأ بالقالب**: شغّل `yarn entity:add` واختر خيار إضافة وظيفة منطقية جديدة. يُولّد هذا ملفًا مبدئيًا مع معالج وتكوين. +* **يدوي**: أنشئ ملفًا جديدًا `*.logic-function.ts` واستخدم `defineLogicFunction()` مع اتباع النمط نفسه. -### Front components +### المكوّنات الأمامية -Front components let you build custom React components that render within Twenty's UI. Use `defineFrontComponent()` to define components with built-in validation: +تتيح لك المكوّنات الأمامية إنشاء مكوّنات React مخصّصة تُعرَض داخل واجهة مستخدم Twenty. استخدم `defineFrontComponent()` لتعريف مكوّنات مع تحقّق مدمج: ```typescript // src/my-widget.front-component.tsx @@ -581,15 +581,15 @@ export default defineFrontComponent({ النقاط الرئيسية: -* Front components are React components that render in isolated contexts within Twenty. +* المكوّنات الأمامية هي مكوّنات React تُعرَض ضمن سياقات معزولة داخل Twenty. * استخدم لاحقة الملف `*.front-component.tsx` للاكتشاف التلقائي. -* The `component` field references your React component. -* Components are built and synced automatically during `yarn app:dev`. +* يشير الحقل `component` إلى مكوّن React الخاص بك. +* يتم بناء المكوّنات ومزامنتها تلقائيًا أثناء `yarn app:dev`. -You can create new front components in two ways: +يمكنك إنشاء مكوّنات أمامية جديدة بطريقتين: -* **Scaffolded**: Run `yarn entity:add` and choose the option to add a new front component. -* **Manual**: Create a new `*.front-component.tsx` file and use `defineFrontComponent()`. +* **مُنشأ بالقالب**: شغّل `yarn entity:add` واختر خيار إضافة مكوّن أمامي جديد. +* **يدوي**: أنشئ ملفًا جديدًا `*.front-component.tsx` واستخدم `defineFrontComponent()`. ### عميل مُولَّد مضبوط الأنواع @@ -614,12 +614,12 @@ const { me } = await client.query({ me: { id: true, displayName: true } }); الملاحظات: * لا تحتاج إلى تمرير عنوان URL أو مفتاح واجهة برمجة التطبيقات إلى العميل المُولَّد. يقوم بقراءة `TWENTY_API_URL` و`TWENTY_API_KEY` من process.env وقت التشغيل. -* The API key's permissions are determined by the role referenced in your `application-config.ts` via `defaultRoleUniversalIdentifier`. هذا هو الدور الافتراضي الذي تستخدمه الوظائف المنطقية في تطبيقك. -* يمكن للتطبيقات تعريف أدوار لاتباع مبدأ أقل الامتياز. Grant only the permissions your functions need, then point `defaultRoleUniversalIdentifier` to that role's universal identifier. +* تُحدَّد أذونات مفتاح واجهة برمجة التطبيقات بواسطة الدور المشار إليه في `application-config.ts` عبر `defaultRoleUniversalIdentifier`. هذا هو الدور الافتراضي الذي تستخدمه الوظائف المنطقية في تطبيقك. +* يمكن للتطبيقات تعريف أدوار لاتباع مبدأ أقل الامتياز. امنح فقط الأذونات التي تحتاجها وظائفك، ثم وجّه `defaultRoleUniversalIdentifier` إلى المعرّف الشامل لذلك الدور. ### مثال Hello World -Explore a minimal, end-to-end example that demonstrates objects, logic functions, front components, and multiple triggers [here](https://github.com/twentyhq/twenty/tree/main/packages/twenty-apps/hello-world): +استكشف مثالًا بسيطًا شاملًا من البداية إلى النهاية يوضح الكائنات والوظائف المنطقية والمكوّنات الأمامية ومشغّلات متعددة [هنا](https://github.com/twentyhq/twenty/tree/main/packages/twenty-apps/hello-world): ## إعداد يدوي (بدون المهيئ) diff --git a/packages/twenty-docs/l/cs/developers/extend/capabilities/apps.mdx b/packages/twenty-docs/l/cs/developers/extend/capabilities/apps.mdx index 66c25497c6..5cf18330fb 100644 --- a/packages/twenty-docs/l/cs/developers/extend/capabilities/apps.mdx +++ b/packages/twenty-docs/l/cs/developers/extend/capabilities/apps.mdx @@ -89,20 +89,20 @@ my-twenty-app/ eslint.config.mjs tsconfig.json README.md - public/ # Public assets folder (images, fonts, etc.) + public/ # Složka s veřejnými prostředky (obrázky, písma apod.) src/ - ├── application-config.ts # Required - main application configuration + ├── application-config.ts # Povinné – hlavní konfigurace aplikace ├── roles/ - │ └── default-role.ts # Default role for logic functions + │ └── default-role.ts # Výchozí role pro logické funkce ├── logic-functions/ - │ └── hello-world.ts # Example logic function + │ └── hello-world.ts # Ukázková logická funkce └── front-components/ - └── hello-world.tsx # Example front component + └── hello-world.tsx # Ukázková front-endová komponenta ``` V kostce: -* **package.json**: Declares the app name, version, engines (Node 24+, Yarn 4), and adds `twenty-sdk` plus scripts like `app:dev`, `app:generate`, `entity:add`, `function:logs`, `function:execute`, `app:uninstall`, and authentication commands that delegate to the local `twenty` CLI. +* **package.json**: Deklaruje název aplikace, verzi, engines (Node 24+, Yarn 4) a přidává `twenty-sdk` plus skripty jako `app:dev`, `app:generate`, `entity:add`, `function:logs`, `function:execute`, `app:uninstall` a autentizační příkazy, které delegují na lokální `twenty` CLI. * **.gitignore**: Ignoruje běžné artefakty jako `node_modules`, `.yarn`, `generated/` (typovaný klient), `dist/`, `build/`, složky s coverage, logy a soubory `.env*`. * **yarn.lock**, **.yarnrc.yml**, **.yarn/**: Zamykají a konfigurují nástrojový řetězec Yarn 4 používaný projektem. * **.nvmrc**: Fixuje verzi Node.js požadovanou projektem. @@ -111,23 +111,23 @@ V kostce: * **public/**: Složka pro ukládání veřejných prostředků (obrázky, písma, statické soubory), které bude vaše aplikace poskytovat. Soubory umístěné zde se během synchronizace nahrají a jsou za běhu dostupné. * **src/**: Hlavní místo, kde definujete svou aplikaci jako kód -### Entity detection +### Detekce entit -The SDK detects entities by parsing your TypeScript files for **`export default define({...})`** calls. Each entity type has a corresponding helper function exported from `twenty-sdk`: +SDK detekuje entity analýzou vašich souborů TypeScript a hledá volání **`export default define({...})`**. Každý typ entity má odpovídající pomocnou funkci exportovanou z `twenty-sdk`: -| Helper function | Typ entity | +| Pomocná funkce | Typ entity | | ------------------------ | ------------------------------------- | | `defineObject()` | Definice vlastních objektů | -| `defineLogicFunction()` | Logic function definitions | +| `defineLogicFunction()` | Definice logických funkcí | | `defineFrontComponent()` | Definice frontendových komponent | | `defineRole()` | Definice rolí | -| `defineField()` | Field extensions for existing objects | +| `defineField()` | Rozšíření polí u existujících objektů | - **File naming is flexible.** Entity detection is AST-based — the SDK scans your source files for the `export default define({...})` pattern. You can organize your files and folders however you like. Grouping by entity type (e.g., `logic-functions/`, `roles/`) is just a convention for code organization, not a requirement. + **Pojmenování souborů je flexibilní.** Detekce entit je založená na AST — SDK prochází vaše zdrojové soubory a hledá vzor `export default define({...})`. Soubory a složky můžete organizovat, jak chcete. Seskupování podle typu entity (např. `logic-functions/`, `roles/`) je pouze konvence pro organizaci kódu, nikoli požadavek. -Example of a detected entity: +Příklad detekované entity: ```typescript // This file can be named anything and placed anywhere in src/ @@ -184,18 +184,18 @@ twenty-sdk poskytuje typované stavební bloky a pomocné funkce, které použí ### Pomocné funkce -The SDK provides helper functions for defining your app entities. As described in [Entity detection](#entity-detection), you must use `export default define({...})` for your entities to be detected: +SDK poskytuje pomocné funkce pro definování entit vaší aplikace. Jak je popsáno v [Detekce entit](#entity-detection), musíte použít `export default define({...})`, aby byly vaše entity detekovány: -| Funkce | Účel | -| ------------------------ | ------------------------------------------------------ | -| `defineApplication()` | Configure application metadata (required, one per app) | -| `defineObject()` | Definice vlastních objektů s poli | -| `defineLogicFunction()` | Definice logických funkcí s obslužnými funkcemi | -| `defineFrontComponent()` | Define front components for custom UI | -| `defineRole()` | Konfigurace oprávnění rolí a přístupu k objektům | -| `defineField()` | Extend existing objects with additional fields | +| Funkce | Účel | +| ------------------------ | ----------------------------------------------------------------- | +| `defineApplication()` | Nakonfigurujte metadata aplikace (povinné, jedno na aplikaci) | +| `defineObject()` | Definice vlastních objektů s poli | +| `defineLogicFunction()` | Definice logických funkcí s obslužnými funkcemi | +| `defineFrontComponent()` | Definujte frontendové komponenty pro vlastní uživatelské rozhraní | +| `defineRole()` | Konfigurace oprávnění rolí a přístupu k objektům | +| `defineField()` | Rozšiřte existující objekty o další pole | -These functions validate your configuration at build time and provide IDE autocompletion and type safety. +Tyto funkce validují vaši konfiguraci v době sestavení a poskytují automatické doplňování v IDE a typovou bezpečnost. ### Definování objektů @@ -318,11 +318,11 @@ Poznámky: * Pole `universalIdentifier` jsou deterministická ID, která vlastníte; vygenerujte je jednou a udržujte je stabilní napříč synchronizacemi. * `applicationVariables` se stanou proměnnými prostředí pro vaše funkce (například `DEFAULT_RECIPIENT_NAME` je dostupné jako `process.env.DEFAULT_RECIPIENT_NAME`). -* `defaultRoleUniversalIdentifier` must match the role file (see below). +* `defaultRoleUniversalIdentifier` se musí shodovat se souborem role (viz níže). #### Role a oprávnění -Aplikace mohou definovat role, které zapouzdřují oprávnění k objektům a akcím ve vašem pracovním prostoru. The field `defaultRoleUniversalIdentifier` in `application-config.ts` designates the default role used by your app's logic functions. +Aplikace mohou definovat role, které zapouzdřují oprávnění k objektům a akcím ve vašem pracovním prostoru. Pole `defaultRoleUniversalIdentifier` v `application-config.ts` určuje výchozí roli používanou logickými funkcemi vaší aplikace. * Běhový klíč API vložený jako `TWENTY_API_KEY` je odvozen z této výchozí role funkcí. * Typovaný klient bude omezen oprávněními udělenými této roli. @@ -372,10 +372,10 @@ export default defineRole({ }); ``` -The `universalIdentifier` of this role is then referenced in `application-config.ts` as `defaultRoleUniversalIdentifier`. Jinými slovy: +Na `universalIdentifier` této role se poté odkazuje v `application-config.ts` jako na `defaultRoleUniversalIdentifier`. Jinými slovy: * **\*.role.ts** definuje, co může výchozí role funkce dělat. -* **application-config.ts** points to that role so your functions inherit its permissions. +* **application-config.ts** ukazuje na tuto roli, aby vaše funkce zdědily její oprávnění. Poznámky: @@ -386,7 +386,7 @@ Poznámky: ### Konfigurace logických funkcí a vstupní bod -Each function file uses `defineLogicFunction()` to export a configuration with a handler and optional triggers. +Každý soubor funkce používá `defineLogicFunction()` k exportu konfigurace s obslužnou funkcí (handlerem) a volitelnými spouštěči. ```typescript // src/app/createPostCard.logic-function.ts @@ -551,12 +551,12 @@ const handler = async (event: RoutePayload) => { Nové funkce můžete vytvářet dvěma způsoby: -* **Scaffolded**: Run `yarn entity:add` and choose the option to add a new logic function. Tím se vygeneruje startovací soubor s obslužnou funkcí a konfigurací. -* **Manual**: Create a new `*.logic-function.ts` file and use `defineLogicFunction()`, following the same pattern. +* **Vygenerované**: Spusťte `yarn entity:add` a zvolte možnost přidat novou logickou funkci. Tím se vygeneruje startovací soubor s obslužnou funkcí a konfigurací. +* **Ruční**: Vytvořte nový soubor `*.logic-function.ts` a použijte `defineLogicFunction()` podle stejného vzoru. -### Front components +### Frontendové komponenty -Front components let you build custom React components that render within Twenty's UI. Use `defineFrontComponent()` to define components with built-in validation: +Frontendové komponenty vám umožňují vytvářet vlastní React komponenty, které se vykreslují v rozhraní Twenty. K definování komponent s vestavěnou validací použijte `defineFrontComponent()`: ```typescript // src/my-widget.front-component.tsx @@ -581,15 +581,15 @@ export default defineFrontComponent({ Hlavní body: -* Front components are React components that render in isolated contexts within Twenty. +* Frontendové komponenty jsou React komponenty, které se vykreslují v izolovaných kontextech v rámci Twenty. * Pro automatickou detekci použijte příponu souboru `*.front-component.tsx`. -* The `component` field references your React component. -* Components are built and synced automatically during `yarn app:dev`. +* Pole `component` odkazuje na vaši React komponentu. +* Komponenty se během `yarn app:dev` automaticky sestaví a synchronizují. -You can create new front components in two ways: +Nové frontendové komponenty můžete vytvořit dvěma způsoby: -* **Scaffolded**: Run `yarn entity:add` and choose the option to add a new front component. -* **Manual**: Create a new `*.front-component.tsx` file and use `defineFrontComponent()`. +* **Vygenerované**: Spusťte `yarn entity:add` a zvolte možnost přidat novou frontendovou komponentu. +* **Ruční**: Vytvořte nový soubor `*.front-component.tsx` a použijte `defineFrontComponent()`. ### Generovaný typovaný klient @@ -614,12 +614,12 @@ Když vaše funkce běží na Twenty, platforma před spuštěním kódu vloží Poznámky: * Není nutné předávat URL ani klíč API vygenerovanému klientovi. Za běhu čte `TWENTY_API_URL` a `TWENTY_API_KEY` z process.env. -* The API key's permissions are determined by the role referenced in your `application-config.ts` via `defaultRoleUniversalIdentifier`. Toto je výchozí role používaná logickými funkcemi vaší aplikace. -* Aplikace mohou definovat role podle principu nejmenších oprávnění. Grant only the permissions your functions need, then point `defaultRoleUniversalIdentifier` to that role's universal identifier. +* Oprávnění klíče API jsou určena rolí odkazovanou ve vašem `application-config.ts` prostřednictvím `defaultRoleUniversalIdentifier`. Toto je výchozí role používaná logickými funkcemi vaší aplikace. +* Aplikace mohou definovat role podle principu nejmenších oprávnění. Udělte pouze oprávnění, která vaše funkce potřebují, a poté nastavte `defaultRoleUniversalIdentifier` na univerzální identifikátor této role. ### Příklad Hello World -Explore a minimal, end-to-end example that demonstrates objects, logic functions, front components, and multiple triggers [here](https://github.com/twentyhq/twenty/tree/main/packages/twenty-apps/hello-world): +Prozkoumejte minimalistický end-to-end příklad, který demonstruje objekty, logické funkce, frontendové komponenty a více spouštěčů [zde](https://github.com/twentyhq/twenty/tree/main/packages/twenty-apps/hello-world): ## Ruční nastavení (bez scaffolderu) diff --git a/packages/twenty-docs/l/de/developers/extend/capabilities/apps.mdx b/packages/twenty-docs/l/de/developers/extend/capabilities/apps.mdx index 6e862dd3c1..5559a25310 100644 --- a/packages/twenty-docs/l/de/developers/extend/capabilities/apps.mdx +++ b/packages/twenty-docs/l/de/developers/extend/capabilities/apps.mdx @@ -102,7 +102,7 @@ my-twenty-app/ Auf hoher Ebene: -* **package.json**: Declares the app name, version, engines (Node 24+, Yarn 4), and adds `twenty-sdk` plus scripts like `app:dev`, `app:generate`, `entity:add`, `function:logs`, `function:execute`, `app:uninstall`, and authentication commands that delegate to the local `twenty` CLI. +* **package.json**: Deklariert den App-Namen, die Version, Engines (Node 24+, Yarn 4) und fügt `twenty-sdk` sowie Skripte wie `app:dev`, `app:generate`, `entity:add`, `function:logs`, `function:execute`, `app:uninstall` sowie Authentifizierungsbefehle hinzu, die an die lokale `twenty`-CLI delegieren. * **.gitignore**: Ignoriert übliche Artefakte wie `node_modules`, `.yarn`, `generated/` (typisierter Client), `dist/`, `build/`, Coverage-Ordner, Logdateien und `.env*`-Dateien. * **yarn.lock**, **.yarnrc.yml**, **.yarn/**: Fixieren und konfigurieren die vom Projekt verwendete Yarn-4-Toolchain. * **.nvmrc**: Legt die vom Projekt erwartete Node.js-Version fest. @@ -111,23 +111,23 @@ Auf hoher Ebene: * **public/**: Ein Ordner zum Speichern öffentlicher Assets (Bilder, Schriftarten, statische Dateien), die zusammen mit Ihrer Anwendung bereitgestellt werden. Hier abgelegte Dateien werden während der Synchronisierung hochgeladen und sind zur Laufzeit zugänglich. * **src/**: Der Hauptort, an dem Sie Ihre Anwendung als Code definieren -### Entity detection +### Entitätserkennung -The SDK detects entities by parsing your TypeScript files for **`export default define({...})`** calls. Each entity type has a corresponding helper function exported from `twenty-sdk`: +Das SDK erkennt Entitäten, indem es Ihre TypeScript-Dateien nach Aufrufen von **`export default define({...})`** parst. Für jeden Entitätstyp gibt es eine entsprechende Hilfsfunktion, die aus `twenty-sdk` exportiert wird: -| Helper function | Entitätstyp | -| ------------------------ | ------------------------------------- | -| `defineObject()` | Benutzerdefinierte Objektdefinitionen | -| `defineLogicFunction()` | Logic function definitions | -| `defineFrontComponent()` | Definitionen von Frontend-Komponenten | -| `defineRole()` | Rollendefinitionen | -| `defineField()` | Field extensions for existing objects | +| Hilfsfunktion | Entitätstyp | +| ------------------------ | ---------------------------------------- | +| `defineObject()` | Benutzerdefinierte Objektdefinitionen | +| `defineLogicFunction()` | Definitionen von Logikfunktionen | +| `defineFrontComponent()` | Definitionen von Frontend-Komponenten | +| `defineRole()` | Rollendefinitionen | +| `defineField()` | Felderweiterungen für bestehende Objekte | - **File naming is flexible.** Entity detection is AST-based — the SDK scans your source files for the `export default define({...})` pattern. You can organize your files and folders however you like. Grouping by entity type (e.g., `logic-functions/`, `roles/`) is just a convention for code organization, not a requirement. + **Dateibenennung ist flexibel.** Die Entitätserkennung ist AST-basiert — das SDK durchsucht Ihre Quelldateien nach dem Muster `export default define({...})`. 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. -Example of a detected entity: +Beispiel für eine erkannte Entität: ```typescript // This file can be named anything and placed anywhere in src/ @@ -184,18 +184,18 @@ Das twenty-sdk stellt typisierte Bausteine und Hilfsfunktionen bereit, die Sie i ### Hilfsfunktionen -The SDK provides helper functions for defining your app entities. As described in [Entity detection](#entity-detection), you must use `export default define({...})` for your entities to be detected: +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({...})` verwenden, damit Ihre Entitäten erkannt werden: -| Funktion | Zweck | -| ------------------------ | ------------------------------------------------------ | -| `defineApplication()` | Configure application metadata (required, one per app) | -| `defineObject()` | Benutzerdefinierte Objekte mit Feldern definieren | -| `defineLogicFunction()` | Logikfunktionen mit Handlern definieren | -| `defineFrontComponent()` | Define front components for custom UI | -| `defineRole()` | Rollenberechtigungen und Objektzugriff konfigurieren | -| `defineField()` | Extend existing objects with additional fields | +| Funktion | Zweck | +| ------------------------ | -------------------------------------------------------------- | +| `defineApplication()` | Anwendungsmetadaten konfigurieren (erforderlich, eine pro App) | +| `defineObject()` | Benutzerdefinierte Objekte mit Feldern definieren | +| `defineLogicFunction()` | Logikfunktionen mit Handlern definieren | +| `defineFrontComponent()` | Frontend-Komponenten für benutzerdefinierte UI definieren | +| `defineRole()` | Rollenberechtigungen und Objektzugriff konfigurieren | +| `defineField()` | Bestehende Objekte mit zusätzlichen Feldern erweitern | -These functions validate your configuration at build time and provide IDE autocompletion and type safety. +Diese Funktionen validieren Ihre Konfiguration zur Build-Zeit und bieten IDE-Autovervollständigung sowie Typsicherheit. ### Objekte definieren @@ -318,11 +318,11 @@ 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` must match the role file (see below). +* `defaultRoleUniversalIdentifier` muss mit der Rollendatei übereinstimmen (siehe unten). #### Rollen und Berechtigungen -Anwendungen können Rollen definieren, die Berechtigungen für die Objekte und Aktionen Ihres Workspaces kapseln. The field `defaultRoleUniversalIdentifier` in `application-config.ts` designates the default role used by your app's logic functions. +Anwendungen können Rollen definieren, die Berechtigungen für die Objekte und Aktionen Ihres Workspaces kapseln. Das Feld `defaultRoleUniversalIdentifier` in `application-config.ts` legt die Standardrolle fest, die von den Logikfunktionen Ihrer App verwendet wird. * Der zur Laufzeit als `TWENTY_API_KEY` injizierte API-Schlüssel wird von dieser Standard-Funktionsrolle abgeleitet. * Der typisierte Client ist auf die dieser Rolle gewährten Berechtigungen beschränkt. @@ -372,10 +372,10 @@ export default defineRole({ }); ``` -The `universalIdentifier` of this role is then referenced in `application-config.ts` as `defaultRoleUniversalIdentifier`. Anders ausgedrückt: +Der `universalIdentifier` dieser Rolle wird anschließend in `application-config.ts` als `defaultRoleUniversalIdentifier` referenziert. Anders ausgedrückt: * **\*.role.ts** definiert, was die Standard-Funktionsrolle darf. -* **application-config.ts** points to that role so your functions inherit its permissions. +* **application-config.ts** verweist auf diese Rolle, sodass Ihre Funktionen deren Berechtigungen erben. Notizen: @@ -386,7 +386,7 @@ Notizen: ### Konfiguration von Logikfunktionen und Einstiegspunkt -Each function file uses `defineLogicFunction()` to export a configuration with a handler and optional triggers. +Jede Funktionsdatei verwendet `defineLogicFunction()`, um eine Konfiguration mit einem Handler und optionalen Triggern zu exportieren. ```typescript // src/app/createPostCard.logic-function.ts @@ -551,12 +551,12 @@ const handler = async (event: RoutePayload) => { Sie können neue Funktionen auf zwei Arten erstellen: -* **Scaffolded**: Run `yarn entity:add` and choose the option to add a new logic function. Dadurch wird eine Starterdatei mit Handler und Konfiguration erzeugt. -* **Manual**: Create a new `*.logic-function.ts` file and use `defineLogicFunction()`, following the same pattern. +* **Generiert**: Führen Sie `yarn entity:add` aus und wählen Sie die Option zum Hinzufügen einer neuen Logikfunktion. Dadurch wird eine Starterdatei mit Handler und Konfiguration erzeugt. +* **Manuell**: Erstellen Sie eine neue `*.logic-function.ts`-Datei und verwenden Sie `defineLogicFunction()` nach demselben Muster. -### Front components +### Frontend-Komponenten -Front components let you build custom React components that render within Twenty's UI. Use `defineFrontComponent()` to define components with built-in validation: +Frontend-Komponenten ermöglichen es Ihnen, benutzerdefinierte React-Komponenten zu erstellen, die innerhalb der Twenty-UI gerendert werden. Verwenden Sie `defineFrontComponent()`, um Komponenten mit eingebauter Validierung zu definieren: ```typescript // src/my-widget.front-component.tsx @@ -581,15 +581,15 @@ export default defineFrontComponent({ Hauptpunkte: -* Front components are React components that render in isolated contexts within Twenty. +* Frontend-Komponenten sind React-Komponenten, die in isolierten Kontexten innerhalb von Twenty gerendert werden. * Verwenden Sie die Dateiendung `*.front-component.tsx` für die automatische Erkennung. -* The `component` field references your React component. -* Components are built and synced automatically during `yarn app:dev`. +* Das Feld `component` verweist auf Ihre React-Komponente. +* Komponenten werden während `yarn app:dev` automatisch gebaut und synchronisiert. -You can create new front components in two ways: +Sie können neue Frontend-Komponenten auf zwei Arten erstellen: -* **Scaffolded**: Run `yarn entity:add` and choose the option to add a new front component. -* **Manual**: Create a new `*.front-component.tsx` file and use `defineFrontComponent()`. +* **Generiert**: Führen Sie `yarn entity:add` aus und wählen Sie die Option zum Hinzufügen einer neuen Frontend-Komponente. +* **Manuell**: Erstellen Sie eine neue `*.front-component.tsx`-Datei und verwenden Sie `defineFrontComponent()`. ### Generierter typisierter Client @@ -614,12 +614,12 @@ Wenn Ihre Funktion auf Twenty läuft, injiziert die Plattform vor der Ausführun Notizen: * Sie müssen dem generierten Client weder URL noch API-Schlüssel übergeben. Er liest `TWENTY_API_URL` und `TWENTY_API_KEY` zur Laufzeit aus process.env. -* The API key's permissions are determined by the role referenced in your `application-config.ts` via `defaultRoleUniversalIdentifier`. Dies ist die Standardrolle, die von den Logikfunktionen Ihrer Anwendung verwendet wird. -* Anwendungen können Rollen definieren, um das Least-Privilege-Prinzip einzuhalten. Grant only the permissions your functions need, then point `defaultRoleUniversalIdentifier` to that role's universal identifier. +* Die Berechtigungen des API-Schlüssels werden durch die Rolle bestimmt, auf die in Ihrer `application-config.ts` über `defaultRoleUniversalIdentifier` verwiesen wird. Dies ist die Standardrolle, die von den Logikfunktionen Ihrer Anwendung verwendet wird. +* Anwendungen können Rollen definieren, um das Least-Privilege-Prinzip einzuhalten. Gewähren Sie nur die Berechtigungen, die Ihre Funktionen benötigen, und verweisen Sie dann mit `defaultRoleUniversalIdentifier` auf den universellen Bezeichner dieser Rolle. ### Hello-World-Beispiel -Explore a minimal, end-to-end example that demonstrates objects, logic functions, front components, and multiple triggers [here](https://github.com/twentyhq/twenty/tree/main/packages/twenty-apps/hello-world): +Ein minimales End-to-End-Beispiel, das Objekte, Logikfunktionen, Frontend-Komponenten und mehrere Trigger demonstriert, finden Sie [hier](https://github.com/twentyhq/twenty/tree/main/packages/twenty-apps/hello-world): ## Manuelle Einrichtung (ohne Scaffolder) diff --git a/packages/twenty-docs/l/it/developers/extend/capabilities/apps.mdx b/packages/twenty-docs/l/it/developers/extend/capabilities/apps.mdx index 4de757e8bc..61d6fd1be9 100644 --- a/packages/twenty-docs/l/it/developers/extend/capabilities/apps.mdx +++ b/packages/twenty-docs/l/it/developers/extend/capabilities/apps.mdx @@ -89,20 +89,20 @@ my-twenty-app/ eslint.config.mjs tsconfig.json README.md - public/ # Public assets folder (images, fonts, etc.) + public/ # Cartella delle risorse pubbliche (immagini, font, ecc.) src/ - ├── application-config.ts # Required - main application configuration + ├── application-config.ts # Obbligatorio - configurazione principale dell'applicazione ├── roles/ - │ └── default-role.ts # Default role for logic functions + │ └── default-role.ts # Ruolo predefinito per le funzioni logiche ├── logic-functions/ - │ └── hello-world.ts # Example logic function + │ └── hello-world.ts # Funzione logica di esempio └── front-components/ - └── hello-world.tsx # Example front component + └── hello-world.tsx # Componente front-end di esempio ``` A livello generale: -* **package.json**: Declares the app name, version, engines (Node 24+, Yarn 4), and adds `twenty-sdk` plus scripts like `app:dev`, `app:generate`, `entity:add`, `function:logs`, `function:execute`, `app:uninstall`, and authentication commands that delegate to the local `twenty` CLI. +* **package.json**: Dichiara il nome dell'app, la versione, i motori (Node 24+, Yarn 4) e aggiunge `twenty-sdk`, oltre a script come `app:dev`, `app:generate`, `entity:add`, `function:logs`, `function:execute`, `app:uninstall` e comandi di autenticazione che delegano alla CLI locale `twenty`. * **.gitignore**: Ignora i file generati comuni come `node_modules`, `.yarn`, `generated/` (client tipizzato), `dist/`, `build/`, cartelle di coverage, file di log e file `.env*`. * **yarn.lock**, **.yarnrc.yml**, **.yarn/**: Bloccano e configurano la toolchain Yarn 4 utilizzata dal progetto. * **.nvmrc**: Fissa la versione di Node.js prevista dal progetto. @@ -111,23 +111,23 @@ A livello generale: * **public/**: Una cartella per archiviare risorse pubbliche (immagini, font, file statici) che saranno servite con la tua applicazione. I file collocati qui vengono caricati durante la sincronizzazione e sono accessibili in fase di esecuzione. * **src/**: Il luogo principale in cui definisci la tua applicazione come codice -### Entity detection +### Rilevamento delle entità -The SDK detects entities by parsing your TypeScript files for **`export default define({...})`** calls. Each entity type has a corresponding helper function exported from `twenty-sdk`: +L'SDK rileva le entità analizzando i tuoi file TypeScript alla ricerca di chiamate **`export default define({...})`**. Ogni tipo di entità ha una corrispondente funzione helper esportata da `twenty-sdk`: -| Helper function | Tipo di entità | -| ------------------------ | ------------------------------------- | -| `defineObject()` | Definizioni di oggetti personalizzati | -| `defineLogicFunction()` | Logic function definitions | -| `defineFrontComponent()` | Definizioni dei componenti front-end | -| `defineRole()` | Definizioni di ruoli | -| `defineField()` | Field extensions for existing objects | +| Funzione helper | Tipo di entità | +| ------------------------ | ----------------------------------------- | +| `defineObject()` | Definizioni di oggetti personalizzati | +| `defineLogicFunction()` | Definizioni di funzioni logiche | +| `defineFrontComponent()` | Definizioni dei componenti front-end | +| `defineRole()` | Definizioni di ruoli | +| `defineField()` | Estensioni di campo per oggetti esistenti | - **File naming is flexible.** Entity detection is AST-based — the SDK scans your source files for the `export default define({...})` pattern. You can organize your files and folders however you like. Grouping by entity type (e.g., `logic-functions/`, `roles/`) is just a convention for code organization, not a requirement. + **La denominazione dei file è flessibile.** Il rilevamento delle entità è basato sull'AST — l'SDK esegue la scansione dei file sorgente alla ricerca del pattern `export default define({...})`. Puoi organizzare file e cartelle come preferisci. Raggruppare per tipo di entità (ad es., `logic-functions/`, `roles/`) è solo una convenzione per l'organizzazione del codice, non un requisito. -Example of a detected entity: +Esempio di entità rilevata: ```typescript // This file can be named anything and placed anywhere in src/ @@ -184,18 +184,18 @@ Il pacchetto twenty-sdk fornisce blocchi tipizzati e funzioni helper da usare ne ### Funzioni helper -The SDK provides helper functions for defining your app entities. As described in [Entity detection](#entity-detection), you must use `export default define({...})` for your entities to be detected: +L'SDK fornisce funzioni helper per definire le entità della tua app. Come descritto in [Rilevamento delle entità](#entity-detection), devi usare `export default define({...})` affinché le tue entità vengano rilevate: -| Funzione | Scopo | -| ------------------------ | ------------------------------------------------------- | -| `defineApplication()` | Configure application metadata (required, one per app) | -| `defineObject()` | Definisci oggetti personalizzati con campi | -| `defineLogicFunction()` | Definisci funzioni logiche con handler | -| `defineFrontComponent()` | Define front components for custom UI | -| `defineRole()` | Configura i permessi dei ruoli e l'accesso agli oggetti | -| `defineField()` | Extend existing objects with additional fields | +| Funzione | Scopo | +| ------------------------ | ----------------------------------------------------------------------- | +| `defineApplication()` | Configura i metadati dell'applicazione (obbligatorio, uno per app) | +| `defineObject()` | Definisci oggetti personalizzati con campi | +| `defineLogicFunction()` | Definisci funzioni logiche con handler | +| `defineFrontComponent()` | Definisci componenti front-end per un'interfaccia utente personalizzata | +| `defineRole()` | Configura i permessi dei ruoli e l'accesso agli oggetti | +| `defineField()` | Estendi gli oggetti esistenti con campi aggiuntivi | -These functions validate your configuration at build time and provide IDE autocompletion and type safety. +Queste funzioni convalidano la configurazione in fase di build e offrono il completamento automatico nell'IDE e la sicurezza dei tipi. ### Definizione degli oggetti @@ -318,11 +318,11 @@ Note: * I campi `universalIdentifier` sono ID deterministici sotto il tuo controllo; generali una volta e mantienili stabili tra le sincronizzazioni. * `applicationVariables` diventano variabili d'ambiente per le tue funzioni (ad esempio, `DEFAULT_RECIPIENT_NAME` è disponibile come `process.env.DEFAULT_RECIPIENT_NAME`). -* `defaultRoleUniversalIdentifier` must match the role file (see below). +* `defaultRoleUniversalIdentifier` deve corrispondere al file del ruolo (vedi sotto). #### Ruoli e permessi -Le applicazioni possono definire ruoli che incapsulano i permessi sugli oggetti e sulle azioni del tuo spazio di lavoro. The field `defaultRoleUniversalIdentifier` in `application-config.ts` designates the default role used by your app's logic functions. +Le applicazioni possono definire ruoli che incapsulano i permessi sugli oggetti e sulle azioni del tuo spazio di lavoro. Il campo `defaultRoleUniversalIdentifier` in `application-config.ts` indica il ruolo predefinito utilizzato dalle funzioni logiche della tua app. * La chiave API di runtime iniettata come `TWENTY_API_KEY` è derivata da questo ruolo funzione predefinito. * Il client tipizzato sarà limitato ai permessi concessi a quel ruolo. @@ -372,10 +372,10 @@ export default defineRole({ }); ``` -The `universalIdentifier` of this role is then referenced in `application-config.ts` as `defaultRoleUniversalIdentifier`. In altre parole: +L'`universalIdentifier` di questo ruolo viene quindi referenziato in `application-config.ts` come `defaultRoleUniversalIdentifier`. In altre parole: * **\*.role.ts** definisce ciò che il ruolo funzione predefinito può fare. -* **application-config.ts** points to that role so your functions inherit its permissions. +* **application-config.ts** punta a quel ruolo in modo che le tue funzioni ne ereditino i permessi. Note: @@ -386,7 +386,7 @@ Note: ### Configurazione e punto di ingresso della funzione logica -Each function file uses `defineLogicFunction()` to export a configuration with a handler and optional triggers. +Ogni file di funzione usa `defineLogicFunction()` per esportare una configurazione con un handler e trigger opzionali. ```typescript // src/app/createPostCard.logic-function.ts @@ -551,12 +551,12 @@ const handler = async (event: RoutePayload) => { Puoi creare nuove funzioni in due modi: -* **Scaffolded**: Run `yarn entity:add` and choose the option to add a new logic function. Questo genera un file iniziale con un handler e una configurazione. -* **Manual**: Create a new `*.logic-function.ts` file and use `defineLogicFunction()`, following the same pattern. +* **Generata dallo scaffolder**: Esegui `yarn entity:add` e scegli l'opzione per aggiungere una nuova funzione logica. Questo genera un file iniziale con un handler e una configurazione. +* **Manuale**: Crea un nuovo file `*.logic-function.ts` e usa `defineLogicFunction()`, seguendo lo stesso schema. -### Front components +### Componenti front-end -Front components let you build custom React components that render within Twenty's UI. Use `defineFrontComponent()` to define components with built-in validation: +I componenti front-end ti consentono di creare componenti React personalizzati che vengono renderizzati all'interno dell'interfaccia di Twenty. Usa `defineFrontComponent()` per definire componenti con convalida integrata: ```typescript // src/my-widget.front-component.tsx @@ -581,15 +581,15 @@ export default defineFrontComponent({ Punti chiave: -* Front components are React components that render in isolated contexts within Twenty. +* I componenti front-end sono componenti React che eseguono il rendering in contesti isolati all'interno di Twenty. * Usa il suffisso di file `*.front-component.tsx` per il rilevamento automatico. -* The `component` field references your React component. -* Components are built and synced automatically during `yarn app:dev`. +* Il campo `component` fa riferimento al tuo componente React. +* I componenti vengono compilati e sincronizzati automaticamente durante `yarn app:dev`. -You can create new front components in two ways: +Puoi creare nuovi componenti front-end in due modi: -* **Scaffolded**: Run `yarn entity:add` and choose the option to add a new front component. -* **Manual**: Create a new `*.front-component.tsx` file and use `defineFrontComponent()`. +* **Generata dallo scaffolder**: Esegui `yarn entity:add` e scegli l'opzione per aggiungere un nuovo componente front-end. +* **Manuale**: Crea un nuovo file `*.front-component.tsx` e usa `defineFrontComponent()`. ### Client tipizzato generato @@ -614,12 +614,12 @@ Quando la tua funzione viene eseguita su Twenty, la piattaforma inietta le crede Note: * Non è necessario passare URL o chiave API al client generato. Legge `TWENTY_API_URL` e `TWENTY_API_KEY` da process.env in fase di esecuzione. -* The API key's permissions are determined by the role referenced in your `application-config.ts` via `defaultRoleUniversalIdentifier`. Questo è il ruolo predefinito utilizzato dalle funzioni logiche della tua applicazione. -* Le applicazioni possono definire ruoli per seguire il principio del privilegio minimo. Grant only the permissions your functions need, then point `defaultRoleUniversalIdentifier` to that role's universal identifier. +* I permessi della chiave API sono determinati dal ruolo referenziato nel tuo `application-config.ts` tramite `defaultRoleUniversalIdentifier`. Questo è il ruolo predefinito utilizzato dalle funzioni logiche della tua applicazione. +* Le applicazioni possono definire ruoli per seguire il principio del privilegio minimo. Concedi solo i permessi necessari alle tue funzioni, quindi punta `defaultRoleUniversalIdentifier` all'identificatore universale di quel ruolo. ### Esempio Hello World -Explore a minimal, end-to-end example that demonstrates objects, logic functions, front components, and multiple triggers [here](https://github.com/twentyhq/twenty/tree/main/packages/twenty-apps/hello-world): +Esplora un esempio minimale end-to-end che dimostra oggetti, funzioni logiche, componenti front-end e trigger multipli [qui](https://github.com/twentyhq/twenty/tree/main/packages/twenty-apps/hello-world): ## Configurazione manuale (senza lo scaffolder) diff --git a/packages/twenty-docs/l/pt/developers/extend/capabilities/apps.mdx b/packages/twenty-docs/l/pt/developers/extend/capabilities/apps.mdx index d98a3edcbd..efb1b5dc51 100644 --- a/packages/twenty-docs/l/pt/developers/extend/capabilities/apps.mdx +++ b/packages/twenty-docs/l/pt/developers/extend/capabilities/apps.mdx @@ -89,20 +89,20 @@ my-twenty-app/ eslint.config.mjs tsconfig.json README.md - public/ # Public assets folder (images, fonts, etc.) + public/ # Pasta de recursos públicos (imagens, fontes, etc.) src/ - ├── application-config.ts # Required - main application configuration + ├── application-config.ts # Obrigatório - configuração principal da aplicação ├── roles/ - │ └── default-role.ts # Default role for logic functions + │ └── default-role.ts # Papel padrão para funções de lógica ├── logic-functions/ - │ └── hello-world.ts # Example logic function + │ └── hello-world.ts # Exemplo de função de lógica └── front-components/ - └── hello-world.tsx # Example front component + └── hello-world.tsx # Exemplo de componente de front-end ``` Em alto nível: -* **package.json**: Declares the app name, version, engines (Node 24+, Yarn 4), and adds `twenty-sdk` plus scripts like `app:dev`, `app:generate`, `entity:add`, `function:logs`, `function:execute`, `app:uninstall`, and authentication commands that delegate to the local `twenty` CLI. +* **package.json**: Declara o nome do app, versão, engines (Node 24+, Yarn 4) e adiciona `twenty-sdk`, além de scripts como `app:dev`, `app:generate`, `entity:add`, `function:logs`, `function:execute`, `app:uninstall` e comandos de autenticação que delegam para a CLI local `twenty`. * **.gitignore**: Ignora artefatos comuns como `node_modules`, `.yarn`, `generated/` (cliente tipado), `dist/`, `build/`, pastas de cobertura, arquivos de log e arquivos `.env*`. * **yarn.lock**, **.yarnrc.yml**, **.yarn/**: Bloqueiam e configuram a ferramenta Yarn 4 usada pelo projeto. * **.nvmrc**: Fixa a versão do Node.js esperada pelo projeto. @@ -111,23 +111,23 @@ Em alto nível: * **public/**: Uma pasta para armazenar recursos públicos (imagens, fontes, arquivos estáticos) que serão servidos com sua aplicação. Os arquivos colocados aqui são enviados durante a sincronização e ficam acessíveis em tempo de execução. * **src/**: O local principal onde você define seu aplicativo como código -### Entity detection +### Detecção de entidades -The SDK detects entities by parsing your TypeScript files for **`export default define({...})`** calls. Each entity type has a corresponding helper function exported from `twenty-sdk`: +O SDK detecta entidades analisando seus arquivos TypeScript em busca de chamadas **`export default define({...})`**. Cada tipo de entidade tem uma função utilitária correspondente exportada de `twenty-sdk`: -| Helper function | Tipo de entidade | -| ------------------------ | -------------------------------------- | -| `defineObject()` | Definições de objetos personalizados | -| `defineLogicFunction()` | Logic function definitions | -| `defineFrontComponent()` | Definições de componentes de front-end | -| `defineRole()` | Definições de papéis | -| `defineField()` | Field extensions for existing objects | +| Função utilitária | Tipo de entidade | +| ------------------------ | ------------------------------------------- | +| `defineObject()` | Definições de objetos personalizados | +| `defineLogicFunction()` | Definições de funções de lógica | +| `defineFrontComponent()` | Definições de componentes de front-end | +| `defineRole()` | Definições de papéis | +| `defineField()` | Extensões de campos para objetos existentes | - **File naming is flexible.** Entity detection is AST-based — the SDK scans your source files for the `export default define({...})` pattern. You can organize your files and folders however you like. Grouping by entity type (e.g., `logic-functions/`, `roles/`) is just a convention for code organization, not a requirement. + **A nomeação de arquivos é flexível.** A detecção de entidades é baseada em AST — o SDK varre seus arquivos fonte em busca do padrão `export default define({...})`. Você pode organizar seus arquivos e pastas como quiser. Agrupar por tipo de entidade (por exemplo, `logic-functions/`, `roles/`) é apenas uma convenção para organização do código, não um requisito. -Example of a detected entity: +Exemplo de uma entidade detectada: ```typescript // This file can be named anything and placed anywhere in src/ @@ -184,18 +184,18 @@ O twenty-sdk fornece blocos de construção tipados e funções utilitárias que ### Funções utilitárias -The SDK provides helper functions for defining your app entities. As described in [Entity detection](#entity-detection), you must use `export default define({...})` for your entities to be detected: +O SDK fornece funções utilitárias para definir as entidades do seu app. Conforme descrito em [Detecção de entidades](#entity-detection), você deve usar `export default define({...})` para que suas entidades sejam detectadas: -| Função | Finalidade | -| ------------------------ | ------------------------------------------------------ | -| `defineApplication()` | Configure application metadata (required, one per app) | -| `defineObject()` | Define objetos personalizados com campos | -| `defineLogicFunction()` | Defina funções de lógica com handlers | -| `defineFrontComponent()` | Define front components for custom UI | -| `defineRole()` | Configura permissões de papéis e acesso a objetos | -| `defineField()` | Extend existing objects with additional fields | +| Função | Finalidade | +| ------------------------ | ------------------------------------------------------------ | +| `defineApplication()` | Configurar metadados do aplicativo (obrigatório, um por app) | +| `defineObject()` | Define objetos personalizados com campos | +| `defineLogicFunction()` | Defina funções de lógica com handlers | +| `defineFrontComponent()` | Definir componentes de front-end para UI personalizada | +| `defineRole()` | Configura permissões de papéis e acesso a objetos | +| `defineField()` | Estender objetos existentes com campos adicionais | -These functions validate your configuration at build time and provide IDE autocompletion and type safety. +Essas funções validam sua configuração em tempo de compilação e oferecem autocompletar na IDE e segurança de tipos. ### Definindo objetos @@ -318,11 +318,11 @@ Notas: * `universalIdentifier` são IDs determinísticos que você controla; gere-os uma vez e mantenha-os estáveis entre sincronizações. * `applicationVariables` tornam-se variáveis de ambiente para suas funções (por exemplo, `DEFAULT_RECIPIENT_NAME` fica disponível como `process.env.DEFAULT_RECIPIENT_NAME`). -* `defaultRoleUniversalIdentifier` must match the role file (see below). +* `defaultRoleUniversalIdentifier` deve corresponder ao arquivo do papel (veja abaixo). #### Papéis e permissões -Os aplicativos podem definir papéis que encapsulam permissões sobre os objetos e ações do seu espaço de trabalho. The field `defaultRoleUniversalIdentifier` in `application-config.ts` designates the default role used by your app's logic functions. +Os aplicativos podem definir papéis que encapsulam permissões sobre os objetos e ações do seu espaço de trabalho. O campo `defaultRoleUniversalIdentifier` em `application-config.ts` designa o papel padrão usado pelas funções de lógica do seu app. * A chave de API em tempo de execução, injetada como `TWENTY_API_KEY`, é derivada desse papel padrão de função. * O cliente tipado ficará restrito às permissões concedidas a esse papel. @@ -372,10 +372,10 @@ export default defineRole({ }); ``` -The `universalIdentifier` of this role is then referenced in `application-config.ts` as `defaultRoleUniversalIdentifier`. Em outras palavras: +O `universalIdentifier` desse papel é então referenciado em `application-config.ts` como `defaultRoleUniversalIdentifier`. Em outras palavras: * **\*.role.ts** define o que o papel de função padrão pode fazer. -* **application-config.ts** points to that role so your functions inherit its permissions. +* **application-config.ts** aponta para esse papel para que suas funções herdem suas permissões. Notas: @@ -386,7 +386,7 @@ Notas: ### Configuração de função de lógica e ponto de entrada -Each function file uses `defineLogicFunction()` to export a configuration with a handler and optional triggers. +Cada arquivo de função usa `defineLogicFunction()` para exportar uma configuração com um handler e gatilhos opcionais. ```typescript // src/app/createPostCard.logic-function.ts @@ -551,12 +551,12 @@ const handler = async (event: RoutePayload) => { Você pode criar novas funções de duas formas: -* **Scaffolded**: Run `yarn entity:add` and choose the option to add a new logic function. Isso gera um arquivo inicial com um handler e configuração. -* **Manual**: Create a new `*.logic-function.ts` file and use `defineLogicFunction()`, following the same pattern. +* **Gerado automaticamente**: Execute `yarn entity:add` e escolha a opção para adicionar uma nova função de lógica. Isso gera um arquivo inicial com um handler e configuração. +* **Manual**: Crie um novo arquivo `*.logic-function.ts` e use `defineLogicFunction()`, seguindo o mesmo padrão. -### Front components +### Componentes de front-end -Front components let you build custom React components that render within Twenty's UI. Use `defineFrontComponent()` to define components with built-in validation: +Componentes de front-end permitem criar componentes React personalizados que são renderizados na UI do Twenty. Use `defineFrontComponent()` para definir componentes com validação integrada: ```typescript // src/my-widget.front-component.tsx @@ -581,15 +581,15 @@ export default defineFrontComponent({ Pontos-chave: -* Front components are React components that render in isolated contexts within Twenty. +* Componentes de front-end são componentes React que renderizam em contextos isolados dentro do Twenty. * Use o sufixo de arquivo `*.front-component.tsx` para detecção automática. -* The `component` field references your React component. -* Components are built and synced automatically during `yarn app:dev`. +* O campo `component` faz referência ao seu componente React. +* Os componentes são compilados e sincronizados automaticamente durante `yarn app:dev`. -You can create new front components in two ways: +Você pode criar novos componentes de front-end de duas formas: -* **Scaffolded**: Run `yarn entity:add` and choose the option to add a new front component. -* **Manual**: Create a new `*.front-component.tsx` file and use `defineFrontComponent()`. +* **Gerado automaticamente**: Execute `yarn entity:add` e escolha a opção para adicionar um novo componente de front-end. +* **Manual**: Crie um novo arquivo `*.front-component.tsx` e use `defineFrontComponent()`. ### Cliente tipado gerado @@ -614,12 +614,12 @@ Quando sua função é executada no Twenty, a plataforma injeta credenciais como Notas: * Você não precisa passar a URL ou a chave de API para o cliente gerado. Ele lê `TWENTY_API_URL` e `TWENTY_API_KEY` de process.env em tempo de execução. -* The API key's permissions are determined by the role referenced in your `application-config.ts` via `defaultRoleUniversalIdentifier`. Este é o papel padrão usado pelas funções de lógica do seu app. -* Os aplicativos podem definir papéis para seguir o princípio do menor privilégio. Grant only the permissions your functions need, then point `defaultRoleUniversalIdentifier` to that role's universal identifier. +* As permissões da chave de API são determinadas pelo papel referenciado no seu `application-config.ts` via `defaultRoleUniversalIdentifier`. Este é o papel padrão usado pelas funções de lógica do seu app. +* Os aplicativos podem definir papéis para seguir o princípio do menor privilégio. Conceda apenas as permissões de que suas funções precisam e, em seguida, aponte `defaultRoleUniversalIdentifier` para o identificador universal desse papel. ### Exemplo Hello World -Explore a minimal, end-to-end example that demonstrates objects, logic functions, front components, and multiple triggers [here](https://github.com/twentyhq/twenty/tree/main/packages/twenty-apps/hello-world): +Explore um exemplo mínimo de ponta a ponta que demonstra objetos, funções de lógica, componentes de front-end e vários gatilhos [aqui](https://github.com/twentyhq/twenty/tree/main/packages/twenty-apps/hello-world): ## Configuração manual (sem o gerador) diff --git a/packages/twenty-docs/l/ro/developers/extend/capabilities/apps.mdx b/packages/twenty-docs/l/ro/developers/extend/capabilities/apps.mdx index 43a20bfeb5..8362eca759 100644 --- a/packages/twenty-docs/l/ro/developers/extend/capabilities/apps.mdx +++ b/packages/twenty-docs/l/ro/developers/extend/capabilities/apps.mdx @@ -102,7 +102,7 @@ my-twenty-app/ Pe scurt: -* **package.json**: Declares the app name, version, engines (Node 24+, Yarn 4), and adds `twenty-sdk` plus scripts like `app:dev`, `app:generate`, `entity:add`, `function:logs`, `function:execute`, `app:uninstall`, and authentication commands that delegate to the local `twenty` CLI. +* **package.json**: Declară numele aplicației, versiunea, motoarele (Node 24+, Yarn 4) și adaugă `twenty-sdk` plus scripturi precum `app:dev`, `app:generate`, `entity:add`, `function:logs`, `function:execute`, `app:uninstall`, precum și comenzi de autentificare care deleagă către CLI-ul local `twenty`. * **.gitignore**: Ignoră artefacte comune precum `node_modules`, `.yarn`, `generated/` (client tipizat), `dist/`, `build/`, foldere de coverage, fișiere jurnal și fișiere `.env*`. * **yarn.lock**, **.yarnrc.yml**, **.yarn/**: Blochează și configurează lanțul de instrumente Yarn 4 folosit de proiect. * **.nvmrc**: Fixează versiunea Node.js așteptată de proiect. @@ -111,23 +111,23 @@ Pe scurt: * **public/**: Un folder pentru stocarea resurselor publice (imagini, fonturi, fișiere statice) care vor fi servite împreună cu aplicația ta. Fișierele plasate aici sunt încărcate în timpul sincronizării și sunt accesibile la rulare. * **src/**: Locul principal unde vă definiți aplicația sub formă de cod -### Entity detection +### Detectarea entităților -The SDK detects entities by parsing your TypeScript files for **`export default define({...})`** calls. Each entity type has a corresponding helper function exported from `twenty-sdk`: +SDK-ul detectează entitățile analizând fișierele TypeScript pentru apeluri **`export default define({...})`**. Fiecare tip de entitate are o funcție ajutătoare corespunzătoare, exportată din `twenty-sdk`: -| Helper function | Tipul entității | -| ------------------------ | ---------------------------------------- | -| `defineObject()` | Definiții de obiecte personalizate | -| `defineLogicFunction()` | Logic function definitions | -| `defineFrontComponent()` | Definiții ale componentelor de interfață | -| `defineRole()` | Definiții de rol | -| `defineField()` | Field extensions for existing objects | +| Funcție ajutătoare | Tipul entității | +| ------------------------ | ------------------------------------------- | +| `defineObject()` | Definiții de obiecte personalizate | +| `defineLogicFunction()` | Definiții de funcții de logică | +| `defineFrontComponent()` | Definiții ale componentelor de interfață | +| `defineRole()` | Definiții de rol | +| `defineField()` | Extensii de câmp pentru obiectele existente | - **File naming is flexible.** Entity detection is AST-based — the SDK scans your source files for the `export default define({...})` pattern. You can organize your files and folders however you like. Grouping by entity type (e.g., `logic-functions/`, `roles/`) is just a convention for code organization, not a requirement. + **Denumirea fișierelor este flexibilă.** Detectarea entităților se bazează pe AST — SDK-ul scanează fișierele sursă pentru tiparul `export default define({...})`. Puteți organiza fișierele și folderele cum doriți. Gruparea după tipul de entitate (de exemplu, `logic-functions/`, `roles/`) este doar o convenție pentru organizarea codului, nu o cerință. -Example of a detected entity: +Exemplu de entitate detectată: ```typescript // This file can be named anything and placed anywhere in src/ @@ -184,18 +184,18 @@ Biblioteca twenty-sdk oferă blocuri de bază tipizate și funcții ajutătoare ### Funcții ajutătoare -The SDK provides helper functions for defining your app entities. As described in [Entity detection](#entity-detection), you must use `export default define({...})` for your entities to be detected: +SDK-ul oferă funcții ajutătoare pentru definirea entităților aplicației. După cum este descris în [Detectarea entităților](#entity-detection), trebuie să folosiți `export default define({...})` pentru ca entitățile să fie detectate: -| Funcție | Scop | -| ------------------------ | -------------------------------------------------------- | -| `defineApplication()` | Configure application metadata (required, one per app) | -| `defineObject()` | Definiți obiecte personalizate cu câmpuri | -| `defineLogicFunction()` | Definiți funcții de logică cu handleri | -| `defineFrontComponent()` | Define front components for custom UI | -| `defineRole()` | Configurați permisiunile rolurilor și accesul la obiecte | -| `defineField()` | Extend existing objects with additional fields | +| Funcție | Scop | +| ------------------------ | ---------------------------------------------------------------------- | +| `defineApplication()` | Configurați metadatele aplicației (obligatoriu, una per aplicație) | +| `defineObject()` | Definiți obiecte personalizate cu câmpuri | +| `defineLogicFunction()` | Definiți funcții de logică cu handleri | +| `defineFrontComponent()` | Definiți componente Front pentru interfața de utilizator personalizată | +| `defineRole()` | Configurați permisiunile rolurilor și accesul la obiecte | +| `defineField()` | Extindeți obiectele existente cu câmpuri suplimentare | -These functions validate your configuration at build time and provide IDE autocompletion and type safety. +Aceste funcții validează configurația în timpul build-ului și oferă completare automată în IDE și siguranța tipurilor. ### Definirea obiectelor @@ -318,11 +318,11 @@ Notițe: * Câmpurile `universalIdentifier` sunt ID-uri deterministe pe care le dețineți; generați-le o singură dată și păstrați-le stabile între sincronizări. * `applicationVariables` devin variabile de mediu pentru funcțiile dvs. (de exemplu, `DEFAULT_RECIPIENT_NAME` este disponibil ca `process.env.DEFAULT_RECIPIENT_NAME`). -* `defaultRoleUniversalIdentifier` must match the role file (see below). +* `defaultRoleUniversalIdentifier` trebuie să corespundă fișierului de rol (vedeți mai jos). #### Roluri și permisiuni -Aplicațiile pot defini roluri care încapsulează permisiuni asupra obiectelor și acțiunilor din spațiul dvs. de lucru. The field `defaultRoleUniversalIdentifier` in `application-config.ts` designates the default role used by your app's logic functions. +Aplicațiile pot defini roluri care încapsulează permisiuni asupra obiectelor și acțiunilor din spațiul dvs. de lucru. Câmpul `defaultRoleUniversalIdentifier` din `application-config.ts` desemnează rolul implicit utilizat de funcțiile de logică ale aplicației. * Cheia API de runtime injectată ca `TWENTY_API_KEY` este derivată din acest rol implicit pentru funcții. * Clientul tipizat va fi restricționat la permisiunile acordate acelui rol. @@ -372,10 +372,10 @@ export default defineRole({ }); ``` -The `universalIdentifier` of this role is then referenced in `application-config.ts` as `defaultRoleUniversalIdentifier`. Cu alte cuvinte: +`universalIdentifier` al acestui rol este apoi referențiat în `application-config.ts` ca `defaultRoleUniversalIdentifier`. Cu alte cuvinte: * **\*.role.ts** definește ce poate face rolul implicit pentru funcții. -* **application-config.ts** points to that role so your functions inherit its permissions. +* **application-config.ts** indică acel rol, astfel încât funcțiile moștenesc permisiunile lui. Notițe: @@ -386,7 +386,7 @@ Notițe: ### Configurația funcției de logică și punctul de intrare -Each function file uses `defineLogicFunction()` to export a configuration with a handler and optional triggers. +Fiecare fișier de funcție folosește `defineLogicFunction()` pentru a exporta o configurație cu un handler și declanșatoare opționale. ```typescript // src/app/createPostCard.logic-function.ts @@ -551,12 +551,12 @@ const handler = async (event: RoutePayload) => { Puteți crea funcții noi în două moduri: -* **Scaffolded**: Run `yarn entity:add` and choose the option to add a new logic function. Aceasta generează un fișier inițial cu un handler și o configurație. -* **Manual**: Create a new `*.logic-function.ts` file and use `defineLogicFunction()`, following the same pattern. +* **Generat**: Rulați `yarn entity:add` și alegeți opțiunea de a adăuga o funcție de logică nouă. Aceasta generează un fișier inițial cu un handler și o configurație. +* **Manual**: Creați un fișier nou `*.logic-function.ts` și folosiți `defineLogicFunction()`, urmând același model. -### Front components +### Componente Front -Front components let you build custom React components that render within Twenty's UI. Use `defineFrontComponent()` to define components with built-in validation: +Componentele Front vă permit să construiți componente React personalizate care sunt randate în interfața Twenty. Utilizați `defineFrontComponent()` pentru a defini componente cu validare încorporată: ```typescript // src/my-widget.front-component.tsx @@ -581,15 +581,15 @@ export default defineFrontComponent({ Puncte cheie: -* Front components are React components that render in isolated contexts within Twenty. +* Componentele Front sunt componente React care sunt randate în contexte izolate în cadrul Twenty. * Folosiți sufixul de fișier `*.front-component.tsx` pentru detectare automată. -* The `component` field references your React component. -* Components are built and synced automatically during `yarn app:dev`. +* Câmpul `component` face referire la componenta React. +* Componentele sunt construite și sincronizate automat în timpul `yarn app:dev`. -You can create new front components in two ways: +Puteți crea componente Front noi în două moduri: -* **Scaffolded**: Run `yarn entity:add` and choose the option to add a new front component. -* **Manual**: Create a new `*.front-component.tsx` file and use `defineFrontComponent()`. +* **Generat**: Rulați `yarn entity:add` și alegeți opțiunea de a adăuga o componentă Front nouă. +* **Manual**: Creați un fișier nou `*.front-component.tsx` și folosiți `defineFrontComponent()`. ### Client tipizat generat @@ -614,12 +614,12 @@ Când funcția rulează pe Twenty, platforma injectează acreditări ca variabil Notițe: * Nu trebuie să transmiteți URL-ul sau cheia API către clientul generat. Acesta citește `TWENTY_API_URL` și `TWENTY_API_KEY` din process.env la runtime. -* The API key's permissions are determined by the role referenced in your `application-config.ts` via `defaultRoleUniversalIdentifier`. Acesta este rolul implicit folosit de funcțiile de logică ale aplicației. -* Aplicațiile pot defini roluri pentru a urma principiul celui mai mic privilegiu. Grant only the permissions your functions need, then point `defaultRoleUniversalIdentifier` to that role's universal identifier. +* Permisiunile cheii API sunt determinate de rolul referențiat în `application-config.ts` prin `defaultRoleUniversalIdentifier`. Acesta este rolul implicit folosit de funcțiile de logică ale aplicației. +* Aplicațiile pot defini roluri pentru a urma principiul celui mai mic privilegiu. Acordați doar permisiunile de care au nevoie funcțiile, apoi setați `defaultRoleUniversalIdentifier` la identificatorul universal al acelui rol. ### Exemplu Hello World -Explore a minimal, end-to-end example that demonstrates objects, logic functions, front components, and multiple triggers [here](https://github.com/twentyhq/twenty/tree/main/packages/twenty-apps/hello-world): +Explorați un exemplu minim, cap la cap, care demonstrează obiecte, funcții de logică, componente Front și declanșatoare multiple [aici](https://github.com/twentyhq/twenty/tree/main/packages/twenty-apps/hello-world): ## Configurare manuală (fără generator) diff --git a/packages/twenty-docs/l/ru/developers/extend/capabilities/apps.mdx b/packages/twenty-docs/l/ru/developers/extend/capabilities/apps.mdx index 19f84484a5..770b9d371d 100644 --- a/packages/twenty-docs/l/ru/developers/extend/capabilities/apps.mdx +++ b/packages/twenty-docs/l/ru/developers/extend/capabilities/apps.mdx @@ -89,20 +89,20 @@ my-twenty-app/ eslint.config.mjs tsconfig.json README.md - public/ # Public assets folder (images, fonts, etc.) + public/ # Папка общедоступных ресурсов (изображения, шрифты и т. п.) src/ - ├── application-config.ts # Required - main application configuration + ├── application-config.ts # Обязательный — основная конфигурация приложения ├── roles/ - │ └── default-role.ts # Default role for logic functions + │ └── default-role.ts # Роль по умолчанию для логических функций ├── logic-functions/ - │ └── hello-world.ts # Example logic function + │ └── hello-world.ts # Пример логической функции └── front-components/ - └── hello-world.tsx # Example front component + └── hello-world.tsx # Пример фронтенд-компонента ``` В общих чертах: -* **package.json**: Declares the app name, version, engines (Node 24+, Yarn 4), and adds `twenty-sdk` plus scripts like `app:dev`, `app:generate`, `entity:add`, `function:logs`, `function:execute`, `app:uninstall`, and authentication commands that delegate to the local `twenty` CLI. +* **package.json**: Объявляет имя приложения, версию, движки (Node 24+, Yarn 4) и добавляет `twenty-sdk`, а также скрипты вроде `app:dev`, `app:generate`, `entity:add`, `function:logs`, `function:execute`, `app:uninstall` и команды аутентификации, которые делегируют выполнение локальному CLI `twenty`. * **.gitignore**: Игнорирует распространённые артефакты, такие как `node_modules`, `.yarn`, `generated/` (типизированный клиент), `dist/`, `build/`, каталоги coverage, файлы журналов и файлы `.env*`. * **yarn.lock**, **.yarnrc.yml**, **.yarn/**: Фиксируют и настраивают используемый в проекте инструментарий Yarn 4. * **.nvmrc**: Фиксирует версию Node.js, ожидаемую проектом. @@ -111,23 +111,23 @@ my-twenty-app/ * **public/**: Папка для хранения общедоступных ресурсов (изображений, шрифтов, статических файлов), которые будут отдаваться вашим приложением. Файлы, размещённые здесь, загружаются во время синхронизации и доступны во время выполнения. * **src/**: Основное место, где вы определяете приложение как код -### Entity detection +### Обнаружение сущностей -The SDK detects entities by parsing your TypeScript files for **`export default define({...})`** calls. Each entity type has a corresponding helper function exported from `twenty-sdk`: +SDK обнаруживает сущности, разбирая ваши файлы TypeScript в поисках вызовов **`export default define({...})`**. Для каждого типа сущности существует соответствующая вспомогательная функция, экспортируемая из `twenty-sdk`: -| Helper function | Тип сущности | -| ------------------------ | ------------------------------------- | -| `defineObject()` | Определения пользовательских объектов | -| `defineLogicFunction()` | Logic function definitions | -| `defineFrontComponent()` | Определения компонентов фронтенда | -| `defineRole()` | Определения ролей | -| `defineField()` | Field extensions for existing objects | +| Вспомогательная функция | Тип сущности | +| ------------------------ | ------------------------------------------ | +| `defineObject()` | Определения пользовательских объектов | +| `defineLogicFunction()` | Определения логических функций | +| `defineFrontComponent()` | Определения компонентов фронтенда | +| `defineRole()` | Определения ролей | +| `defineField()` | Расширения полей для существующих объектов | - **File naming is flexible.** Entity detection is AST-based — the SDK scans your source files for the `export default define({...})` pattern. You can organize your files and folders however you like. Grouping by entity type (e.g., `logic-functions/`, `roles/`) is just a convention for code organization, not a requirement. + **Имена файлов заданы гибко.** Обнаружение сущностей основано на AST — SDK сканирует ваши исходные файлы в поисках шаблона `export default define({...})`. Вы можете организовывать файлы и папки как угодно. Группировка по типу сущности (например, `logic-functions/`, `roles/`) — это лишь соглашение для организации кода, а не требование. -Example of a detected entity: +Пример обнаруженной сущности: ```typescript // This file can be named anything and placed anywhere in src/ @@ -184,18 +184,18 @@ yarn auth:status ### Вспомогательные функции -The SDK provides helper functions for defining your app entities. As described in [Entity detection](#entity-detection), you must use `export default define({...})` for your entities to be detected: +SDK предоставляет вспомогательные функции для определения сущностей вашего приложения. Как описано в [Обнаружение сущностей](#entity-detection), вы должны использовать `export default define({...})`, чтобы ваши сущности были обнаружены: -| Функция | Назначение | -| ------------------------ | ------------------------------------------------------ | -| `defineApplication()` | Configure application metadata (required, one per app) | -| `defineObject()` | Определяет пользовательские объекты с полями | -| `defineLogicFunction()` | Определение логических функций с обработчиками | -| `defineFrontComponent()` | Define front components for custom UI | -| `defineRole()` | Настраивает права роли и доступ к объектам | -| `defineField()` | Extend existing objects with additional fields | +| Функция | Назначение | +| ------------------------ | ---------------------------------------------------------------------- | +| `defineApplication()` | Настройка метаданных приложения (обязательно, по одному на приложение) | +| `defineObject()` | Определяет пользовательские объекты с полями | +| `defineLogicFunction()` | Определение логических функций с обработчиками | +| `defineFrontComponent()` | Определение фронт-компонентов для настраиваемого интерфейса | +| `defineRole()` | Настраивает права роли и доступ к объектам | +| `defineField()` | Расширение существующих объектов дополнительными полями | -These functions validate your configuration at build time and provide IDE autocompletion and type safety. +Эти функции проверяют вашу конфигурацию на этапе сборки и обеспечивают автодополнение в IDE и безопасность типов. ### Определение объектов @@ -318,11 +318,11 @@ export default defineApplication({ * `universalIdentifier` — это детерминированные идентификаторы, которыми вы управляете; сгенерируйте их один раз и сохраняйте стабильными между синхронизациями. * `applicationVariables` становятся переменными окружения для ваших функций (например, `DEFAULT_RECIPIENT_NAME` доступна как `process.env.DEFAULT_RECIPIENT_NAME`). -* `defaultRoleUniversalIdentifier` must match the role file (see below). +* `defaultRoleUniversalIdentifier` должен соответствовать файлу роли (см. ниже). #### Роли и разрешения -Приложения могут определять роли, инкапсулирующие права на объекты и действия в вашем рабочем пространстве. The field `defaultRoleUniversalIdentifier` in `application-config.ts` designates the default role used by your app's logic functions. +Приложения могут определять роли, инкапсулирующие права на объекты и действия в вашем рабочем пространстве. Поле `defaultRoleUniversalIdentifier` в `application-config.ts` обозначает роль по умолчанию, используемую логическими функциями вашего приложения. * Ключ API во время выполнения, подставляемый как `TWENTY_API_KEY`, получается из этой роли функции по умолчанию. * Типизированный клиент будет ограничен правами, предоставленными этой ролью. @@ -372,10 +372,10 @@ export default defineRole({ }); ``` -The `universalIdentifier` of this role is then referenced in `application-config.ts` as `defaultRoleUniversalIdentifier`. Иными словами: +Значение `universalIdentifier` этой роли затем указывается в `application-config.ts` как `defaultRoleUniversalIdentifier`. Иными словами: * **\*.role.ts** определяет, что может делать роль функции по умолчанию. -* **application-config.ts** points to that role so your functions inherit its permissions. +* **application-config.ts** указывает на эту роль, чтобы ваши функции наследовали её права. Заметки: @@ -386,7 +386,7 @@ The `universalIdentifier` of this role is then referenced in `application-config ### Конфигурация логической функции и точка входа -Each function file uses `defineLogicFunction()` to export a configuration with a handler and optional triggers. +Каждый файл функции использует `defineLogicFunction()` для экспорта конфигурации с обработчиком и необязательными триггерами. ```typescript // src/app/createPostCard.logic-function.ts @@ -551,12 +551,12 @@ const handler = async (event: RoutePayload) => { Вы можете создать новые функции двумя способами: -* **Scaffolded**: Run `yarn entity:add` and choose the option to add a new logic function. Это создаёт стартовый файл с обработчиком и конфигурацией. -* **Manual**: Create a new `*.logic-function.ts` file and use `defineLogicFunction()`, following the same pattern. +* **Сгенерировано**: Запустите `yarn entity:add` и выберите опцию добавления новой логической функции. Это создаёт стартовый файл с обработчиком и конфигурацией. +* **Вручную**: Создайте новый файл `*.logic-function.ts` и используйте `defineLogicFunction()`, следуя тому же шаблону. -### Front components +### Фронт-компоненты -Front components let you build custom React components that render within Twenty's UI. Use `defineFrontComponent()` to define components with built-in validation: +Фронт-компоненты позволяют создавать пользовательские компоненты React, которые рендерятся внутри интерфейса Twenty. Используйте `defineFrontComponent()` для определения компонентов со встроенной валидацией: ```typescript // src/my-widget.front-component.tsx @@ -581,15 +581,15 @@ export default defineFrontComponent({ Основные моменты: -* Front components are React components that render in isolated contexts within Twenty. +* Фронт-компоненты — это компоненты React, которые рендерятся в изолированных контекстах внутри Twenty. * Используйте суффикс файла `*.front-component.tsx` для автоматического обнаружения. -* The `component` field references your React component. -* Components are built and synced automatically during `yarn app:dev`. +* Поле `component` ссылается на ваш компонент React. +* Компоненты автоматически собираются и синхронизируются во время `yarn app:dev`. -You can create new front components in two ways: +Вы можете создать новые фронт-компоненты двумя способами: -* **Scaffolded**: Run `yarn entity:add` and choose the option to add a new front component. -* **Manual**: Create a new `*.front-component.tsx` file and use `defineFrontComponent()`. +* **Сгенерировано**: Запустите `yarn entity:add` и выберите опцию добавления нового фронт-компонента. +* **Вручную**: Создайте новый файл `*.front-component.tsx` и используйте `defineFrontComponent()`. ### Сгенерированный типизированный клиент @@ -614,12 +614,12 @@ const { me } = await client.query({ me: { id: true, displayName: true } }); Заметки: * Вам не нужно передавать URL или ключ API сгенерированному клиенту. Он читает `TWENTY_API_URL` и `TWENTY_API_KEY` из process.env во время выполнения. -* The API key's permissions are determined by the role referenced in your `application-config.ts` via `defaultRoleUniversalIdentifier`. Это роль по умолчанию, используемая логическими функциями вашего приложения. -* Приложения могут определять роли, чтобы следовать принципу наименьших привилегий. Grant only the permissions your functions need, then point `defaultRoleUniversalIdentifier` to that role's universal identifier. +* Права ключа API определяются ролью, на которую ссылается ваш `application-config.ts` через `defaultRoleUniversalIdentifier`. Это роль по умолчанию, используемая логическими функциями вашего приложения. +* Приложения могут определять роли, чтобы следовать принципу наименьших привилегий. Предоставляйте только те права, которые нужны вашим функциям, затем укажите в `defaultRoleUniversalIdentifier` универсальный идентификатор этой роли. ### Пример Hello World -Explore a minimal, end-to-end example that demonstrates objects, logic functions, front components, and multiple triggers [here](https://github.com/twentyhq/twenty/tree/main/packages/twenty-apps/hello-world): +Ознакомьтесь с минимальным сквозным примером, демонстрирующим объекты, логические функции, фронт-компоненты и несколько триггеров, [здесь](https://github.com/twentyhq/twenty/tree/main/packages/twenty-apps/hello-world): ## Ручная настройка (без генератора) diff --git a/packages/twenty-docs/l/tr/developers/extend/capabilities/apps.mdx b/packages/twenty-docs/l/tr/developers/extend/capabilities/apps.mdx index 7198877148..19a031e9d9 100644 --- a/packages/twenty-docs/l/tr/developers/extend/capabilities/apps.mdx +++ b/packages/twenty-docs/l/tr/developers/extend/capabilities/apps.mdx @@ -89,20 +89,20 @@ my-twenty-app/ eslint.config.mjs tsconfig.json README.md - public/ # Public assets folder (images, fonts, etc.) + public/ # Genel varlıklar klasörü (görseller, yazı tipleri vb.) src/ - ├── application-config.ts # Required - main application configuration + ├── application-config.ts # Gerekli - ana uygulama yapılandırması ├── roles/ - │ └── default-role.ts # Default role for logic functions + │ └── default-role.ts # Mantık işlevleri için varsayılan rol ├── logic-functions/ - │ └── hello-world.ts # Example logic function + │ └── hello-world.ts # Örnek mantık işlevi └── front-components/ - └── hello-world.tsx # Example front component + └── hello-world.tsx # Örnek ön uç bileşeni ``` Genel hatlarıyla: -* **package.json**: Declares the app name, version, engines (Node 24+, Yarn 4), and adds `twenty-sdk` plus scripts like `app:dev`, `app:generate`, `entity:add`, `function:logs`, `function:execute`, `app:uninstall`, and authentication commands that delegate to the local `twenty` CLI. +* **package.json**: Uygulama adını, sürümünü, motorları (Node 24+, Yarn 4) bildirir ve `twenty-sdk` ile `app:dev`, `app:generate`, `entity:add`, `function:logs`, `function:execute`, `app:uninstall` gibi betikleri ve yerel `twenty` CLI’sine yetki devreden kimlik doğrulama komutlarını ekler. * **.gitignore**: `node_modules`, `.yarn`, `generated/` (türlendirilmiş istemci), `dist/`, `build/`, kapsam klasörleri, günlük dosyaları ve `.env*` dosyaları gibi yaygın artifaktları yok sayar. * **yarn.lock**, **.yarnrc.yml**, **.yarn/**: Proje tarafından kullanılan Yarn 4 araç zincirini kilitler ve yapılandırır. * **.nvmrc**: Projenin beklediği Node.js sürümünü sabitler. @@ -111,23 +111,23 @@ Genel hatlarıyla: * **public/**: Uygulamanızla birlikte sunulacak genel varlıkları (görseller, yazı tipleri, statik dosyalar) depolamak için bir klasör. Buraya yerleştirilen dosyalar senkronizasyon sırasında yüklenir ve çalışma zamanında erişilebilir olur. * **src/**: Uygulamanızı kod olarak tanımladığınız ana yer -### Entity detection +### Varlık algılama -The SDK detects entities by parsing your TypeScript files for **`export default define({...})`** calls. Each entity type has a corresponding helper function exported from `twenty-sdk`: +SDK, TypeScript dosyalarınızı **`export default define({...})`** çağrılarını arayarak ayrıştırıp varlıkları algılar. Her varlık türünün, `twenty-sdk` tarafından dışa aktarılan karşılık gelen bir yardımcı fonksiyonu vardır: -| Helper function | Varlık türü | -| ------------------------ | ------------------------------------- | -| `defineObject()` | Özel nesne tanımları | -| `defineLogicFunction()` | Logic function definitions | -| `defineFrontComponent()` | Front component definitions | -| `defineRole()` | Rol tanımları | -| `defineField()` | Field extensions for existing objects | +| Yardımcı fonksiyon | Varlık türü | +| ------------------------ | ---------------------------------------- | +| `defineObject()` | Özel nesne tanımları | +| `defineLogicFunction()` | Mantık fonksiyon tanımları | +| `defineFrontComponent()` | Front component definitions | +| `defineRole()` | Rol tanımları | +| `defineField()` | Mevcut nesneler için alan genişletmeleri | - **File naming is flexible.** Entity detection is AST-based — the SDK scans your source files for the `export default define({...})` pattern. You can organize your files and folders however you like. Grouping by entity type (e.g., `logic-functions/`, `roles/`) is just a convention for code organization, not a requirement. + **Dosya adlandırma esnektir.** Varlık algılama AST tabanlıdır — SDK, kaynak dosyalarınızı `export default define({...})` desenini bulmak için tarar. Dosyalarınızı ve klasörlerinizi dilediğiniz gibi düzenleyebilirsiniz. Varlık türüne göre gruplama (örn. `logic-functions/`, `roles/`) bir gereklilik değil, yalnızca kod organizasyonu için bir gelenektir. -Example of a detected entity: +Algılanan bir varlığa örnek: ```typescript // This file can be named anything and placed anywhere in src/ @@ -184,18 +184,18 @@ twenty-sdk, uygulamanız içinde kullandığınız türlendirilmiş yapı taşla ### Yardımcı fonksiyonlar -The SDK provides helper functions for defining your app entities. As described in [Entity detection](#entity-detection), you must use `export default define({...})` for your entities to be detected: +SDK, uygulama varlıklarınızı tanımlamak için yardımcı fonksiyonlar sağlar. [Varlık algılama](#entity-detection) bölümünde açıklandığı gibi, varlıklarınızın algılanması için `export default define({...})` kullanmalısınız: -| Fonksiyon | Amaç | -| ------------------------ | ------------------------------------------------------ | -| `defineApplication()` | Configure application metadata (required, one per app) | -| `defineObject()` | Alanlara sahip özel nesneler tanımlayın | -| `defineLogicFunction()` | İşleyicilerle mantık fonksiyonları tanımlayın | -| `defineFrontComponent()` | Define front components for custom UI | -| `defineRole()` | Rol izinlerini ve nesne erişimini yapılandırın | -| `defineField()` | Extend existing objects with additional fields | +| Fonksiyon | Amaç | +| ------------------------ | ------------------------------------------------------------------------- | +| `defineApplication()` | Uygulama meta verilerini yapılandırın (zorunlu, uygulama başına bir adet) | +| `defineObject()` | Alanlara sahip özel nesneler tanımlayın | +| `defineLogicFunction()` | İşleyicilerle mantık fonksiyonları tanımlayın | +| `defineFrontComponent()` | Özel kullanıcı arayüzü için ön uç bileşenlerini tanımlayın | +| `defineRole()` | Rol izinlerini ve nesne erişimini yapılandırın | +| `defineField()` | Mevcut nesneleri ek alanlarla genişletin | -These functions validate your configuration at build time and provide IDE autocompletion and type safety. +Bu fonksiyonlar, derleme zamanında yapılandırmanızı doğrular ve IDE otomatik tamamlama ile tür güvenliği sağlar. ### Nesnelerin tanımlanması @@ -318,11 +318,11 @@ Notlar: * `universalIdentifier` alanları size ait belirleyici kimliklerdir; bunları bir kez oluşturun ve eşitlemeler boyunca kararlı tutun. * `applicationVariables`, fonksiyonlarınız için ortam değişkenlerine dönüşür (örneğin, `DEFAULT_RECIPIENT_NAME` değeri `process.env.DEFAULT_RECIPIENT_NAME` olarak kullanılabilir). -* `defaultRoleUniversalIdentifier` must match the role file (see below). +* `defaultRoleUniversalIdentifier`, rol dosyasıyla eşleşmelidir (aşağıya bakın). #### Roller ve izinler -Uygulamalar, çalışma alanınızdaki nesneler ve eylemler üzerindeki izinleri kapsülleyen roller tanımlayabilir. The field `defaultRoleUniversalIdentifier` in `application-config.ts` designates the default role used by your app's logic functions. +Uygulamalar, çalışma alanınızdaki nesneler ve eylemler üzerindeki izinleri kapsülleyen roller tanımlayabilir. `application-config.ts` içindeki `defaultRoleUniversalIdentifier` alanı, uygulamanızın mantık fonksiyonlarının kullandığı varsayılan rolü belirtir. * `TWENTY_API_KEY` olarak enjekte edilen çalışma zamanı API anahtarı bu varsayılan fonksiyon rolünden türetilir. * Türlendirilmiş istemci, o role tanınan izinlerle sınırlandırılır. @@ -372,10 +372,10 @@ export default defineRole({ }); ``` -The `universalIdentifier` of this role is then referenced in `application-config.ts` as `defaultRoleUniversalIdentifier`. Başka bir deyişle: +Bu rolün `universalIdentifier` değeri daha sonra `application-config.ts` içinde `defaultRoleUniversalIdentifier` olarak referans verilir. Başka bir deyişle: * **\*.role.ts**, varsayılan fonksiyon rolünün neler yapabileceğini tanımlar. -* **application-config.ts** points to that role so your functions inherit its permissions. +* **application-config.ts**, fonksiyonlarınızın izinlerini devralması için bu role işaret eder. Notlar: @@ -386,7 +386,7 @@ Notlar: ### Mantık fonksiyon yapılandırması ve giriş noktası -Each function file uses `defineLogicFunction()` to export a configuration with a handler and optional triggers. +Her fonksiyon dosyası, bir işleyici ve isteğe bağlı tetikleyiciler içeren bir yapılandırmayı dışa aktarmak için `defineLogicFunction()` kullanır. ```typescript // src/app/createPostCard.logic-function.ts @@ -551,12 +551,12 @@ const handler = async (event: RoutePayload) => { Yeni fonksiyonları iki şekilde oluşturabilirsiniz: -* **Scaffolded**: Run `yarn entity:add` and choose the option to add a new logic function. Bu, bir işleyici ve yapılandırma içeren bir başlangıç dosyası oluşturur. -* **Manual**: Create a new `*.logic-function.ts` file and use `defineLogicFunction()`, following the same pattern. +* **Şablondan**: `yarn entity:add` çalıştırın ve yeni bir mantık fonksiyonu ekleme seçeneğini seçin. Bu, bir işleyici ve yapılandırma içeren bir başlangıç dosyası oluşturur. +* **Manuel**: Yeni bir `*.logic-function.ts` dosyası oluşturun ve aynı deseni izleyerek `defineLogicFunction()` kullanın. -### Front components +### Ön uç bileşenleri -Front components let you build custom React components that render within Twenty's UI. Use `defineFrontComponent()` to define components with built-in validation: +Ön uç bileşenleri, Twenty'nin kullanıcı arayüzünde görüntülenen özel React bileşenleri oluşturmanıza olanak tanır. Yerleşik doğrulamayla bileşenleri tanımlamak için `defineFrontComponent()` kullanın: ```typescript // src/my-widget.front-component.tsx @@ -581,15 +581,15 @@ export default defineFrontComponent({ Önemli noktalar: -* Front components are React components that render in isolated contexts within Twenty. +* Ön uç bileşenleri, Twenty içinde yalıtılmış bağlamlarda görüntülenen React bileşenleridir. * Otomatik algılama için `*.front-component.tsx` dosya soneğini kullanın. -* The `component` field references your React component. -* Components are built and synced automatically during `yarn app:dev`. +* `component` alanı, React bileşeninize referans verir. +* Bileşenler, `yarn app:dev` sırasında otomatik olarak oluşturulur ve senkronize edilir. -You can create new front components in two ways: +Yeni ön uç bileşenlerini iki şekilde oluşturabilirsiniz: -* **Scaffolded**: Run `yarn entity:add` and choose the option to add a new front component. -* **Manual**: Create a new `*.front-component.tsx` file and use `defineFrontComponent()`. +* **Şablondan**: `yarn entity:add` çalıştırın ve yeni bir ön uç bileşeni ekleme seçeneğini seçin. +* **Manuel**: Yeni bir `*.front-component.tsx` dosyası oluşturun ve `defineFrontComponent()` kullanın. ### Oluşturulmuş türlendirilmiş istemci @@ -614,12 +614,12 @@ Fonksiyonunuz Twenty üzerinde çalıştığında, platform kodunuz yürütülme Notlar: * Oluşturulan istemciye URL veya API anahtarı geçirmeniz gerekmez. Çalışma zamanında `TWENTY_API_URL` ve `TWENTY_API_KEY` değerlerini process.env üzerinden okur. -* The API key's permissions are determined by the role referenced in your `application-config.ts` via `defaultRoleUniversalIdentifier`. Bu, uygulamanızın mantık fonksiyonları tarafından kullanılan varsayılan roldür. -* Uygulamalar, en az ayrıcalık ilkesini izlemek için roller tanımlayabilir. Grant only the permissions your functions need, then point `defaultRoleUniversalIdentifier` to that role's universal identifier. +* API anahtarının izinleri, `application-config.ts` içinde `defaultRoleUniversalIdentifier` aracılığıyla referans verilen role göre belirlenir. Bu, uygulamanızın mantık fonksiyonları tarafından kullanılan varsayılan roldür. +* Uygulamalar, en az ayrıcalık ilkesini izlemek için roller tanımlayabilir. Yalnızca fonksiyonlarınızın ihtiyaç duyduğu izinleri verin ve ardından `defaultRoleUniversalIdentifier` değerini o rolün evrensel tanımlayıcısına yönlendirin. ### Hello World örneği -Explore a minimal, end-to-end example that demonstrates objects, logic functions, front components, and multiple triggers [here](https://github.com/twentyhq/twenty/tree/main/packages/twenty-apps/hello-world): +Nesneleri, mantık fonksiyonlarını, ön uç bileşenlerini ve birden çok tetikleyiciyi gösteren minimal, uçtan uca bir örneği [buradan](https://github.com/twentyhq/twenty/tree/main/packages/twenty-apps/hello-world) inceleyin: ## Manuel kurulum (scaffolder olmadan) diff --git a/packages/twenty-docs/l/zh/developers/extend/capabilities/apps.mdx b/packages/twenty-docs/l/zh/developers/extend/capabilities/apps.mdx index ec8a1851ed..3c6ca46a44 100644 --- a/packages/twenty-docs/l/zh/developers/extend/capabilities/apps.mdx +++ b/packages/twenty-docs/l/zh/developers/extend/capabilities/apps.mdx @@ -89,45 +89,45 @@ my-twenty-app/ eslint.config.mjs tsconfig.json README.md - public/ # Public assets folder (images, fonts, etc.) + public/ # 公共资源文件夹（图像、字体等） src/ - ├── application-config.ts # Required - main application configuration + ├── application-config.ts # 必需 - 主应用程序配置 ├── roles/ - │ └── default-role.ts # Default role for logic functions + │ └── default-role.ts # 用于逻辑函数的默认角色 ├── logic-functions/ - │ └── hello-world.ts # Example logic function + │ └── hello-world.ts # 示例逻辑函数 └── front-components/ - └── hello-world.tsx # Example front component + └── hello-world.tsx # 示例前端组件 ``` 总体来说： -* **package.json**: Declares the app name, version, engines (Node 24+, Yarn 4), and adds `twenty-sdk` plus scripts like `app:dev`, `app:generate`, `entity:add`, `function:logs`, `function:execute`, `app:uninstall`, and authentication commands that delegate to the local `twenty` CLI. +* **package.json**：声明应用名称、版本、运行时（Node 24+、Yarn 4），并添加 `twenty-sdk`，以及诸如 `app:dev`、`app:generate`、`entity:add`、`function:logs`、`function:execute`、`app:uninstall` 等脚本和认证命令，它们都会委托给本地的 `twenty` CLI。 * **.gitignore**：忽略常见产物，如 `node_modules`、`.yarn`、`generated/`（类型化客户端）、`dist/`、`build/`、覆盖率文件夹、日志文件以及 `.env*` 文件。 * **yarn.lock**、**.yarnrc.yml**、**.yarn/**：锁定并配置项目使用的 Yarn 4 工具链。 * **.nvmrc**：固定项目期望的 Node.js 版本。 * **eslint.config.mjs** 和 **tsconfig.json**：为应用的 TypeScript 源码提供 Lint 与 TypeScript 配置。 * **README.md**：应用根目录中的简短 README，包含基本说明。 * **public/**: 一个用于存储公共资源（图像、字体、静态文件）的文件夹，这些资源将随你的应用程序一起提供。 放置在此处的文件会在同步期间上传，并可在运行时访问。 -* **src/**: The main place where you define your application-as-code +* **src/**：你以代码形式定义应用的主要位置 -### Entity detection +### 实体检测 -The SDK detects entities by parsing your TypeScript files for **`export default define({...})`** calls. Each entity type has a corresponding helper function exported from `twenty-sdk`: +该 SDK 通过在你的 TypeScript 文件中解析 **`export default define({...})`** 调用来检测实体。 每种实体类型都有一个从 `twenty-sdk` 导出的对应辅助函数： -| Helper function | 实体类型 | -| ------------------------ | ------------------------------------- | -| `defineObject()` | 自定义对象定义 | -| `defineLogicFunction()` | Logic function definitions | -| `defineFrontComponent()` | 前端组件定义 | -| `defineRole()` | 角色定义 | -| `defineField()` | Field extensions for existing objects | +| 辅助函数 | 实体类型 | +| ------------------------ | --------- | +| `defineObject()` | 自定义对象定义 | +| `defineLogicFunction()` | 逻辑函数定义 | +| `defineFrontComponent()` | 前端组件定义 | +| `defineRole()` | 角色定义 | +| `defineField()` | 现有对象的字段扩展 | - **File naming is flexible.** Entity detection is AST-based — the SDK scans your source files for the `export default define({...})` pattern. You can organize your files and folders however you like. Grouping by entity type (e.g., `logic-functions/`, `roles/`) is just a convention for code organization, not a requirement. + **文件命名是灵活的。** 实体检测基于 AST — SDK 会扫描你的源文件以查找 `export default define({...})` 模式。 你可以按照自己的喜好组织文件和文件夹。 按实体类型分组（例如 `logic-functions/`、`roles/`）只是代码组织的一种约定，并非必需。 -Example of a detected entity: +已检测实体的示例： ```typescript // This file can be named anything and placed anywhere in src/ @@ -184,18 +184,18 @@ twenty-sdk 提供你在应用中使用的类型化构件和辅助函数。 以 ### 辅助函数 -The SDK provides helper functions for defining your app entities. As described in [Entity detection](#entity-detection), you must use `export default define({...})` for your entities to be detected: +该 SDK 提供辅助函数用于定义你的应用实体。 如 [实体检测](#entity-detection) 中所述，你必须使用 `export default define({...})` 才能让你的实体被检测到： -| 函数 | 目的 | -| ------------------------ | ------------------------------------------------------ | -| `defineApplication()` | Configure application metadata (required, one per app) | -| `defineObject()` | 定义带字段的自定义对象 | -| `defineLogicFunction()` | 定义带处理程序的逻辑函数 | -| `defineFrontComponent()` | Define front components for custom UI | -| `defineRole()` | 配置角色权限和对象访问 | -| `defineField()` | Extend existing objects with additional fields | +| 函数 | 目的 | +| ------------------------ | ------------------ | +| `defineApplication()` | 配置应用元数据（必需，每个应用一个） | +| `defineObject()` | 定义带字段的自定义对象 | +| `defineLogicFunction()` | 定义带处理程序的逻辑函数 | +| `defineFrontComponent()` | 为自定义 UI 定义前端组件 | +| `defineRole()` | 配置角色权限和对象访问 | +| `defineField()` | 为现有对象扩展额外字段 | -These functions validate your configuration at build time and provide IDE autocompletion and type safety. +这些函数会在构建时校验你的配置，并提供 IDE 自动补全和类型安全。 ### 定义对象 @@ -318,11 +318,11 @@ export default defineApplication({ * `universalIdentifier` 字段是你拥有的确定性 ID；生成一次并在多次同步中保持稳定。 * `applicationVariables` 会变成函数可用的环境变量（例如，`DEFAULT_RECIPIENT_NAME` 可作为 `process.env.DEFAULT_RECIPIENT_NAME` 使用）。 -* `defaultRoleUniversalIdentifier` must match the role file (see below). +* `defaultRoleUniversalIdentifier` 必须与角色文件一致（见下文）。 #### 角色和权限 -应用可以定义角色，以封装对工作空间对象与操作的权限。 The field `defaultRoleUniversalIdentifier` in `application-config.ts` designates the default role used by your app's logic functions. +应用可以定义角色，以封装对工作空间对象与操作的权限。 `application-config.ts` 中的 `defaultRoleUniversalIdentifier` 字段指定你的应用逻辑函数所使用的默认角色。 * 作为 `TWENTY_API_KEY` 注入的运行时 API 密钥源自该默认函数角色。 * 类型化客户端将受限于该角色授予的权限。 @@ -372,10 +372,10 @@ export default defineRole({ }); ``` -The `universalIdentifier` of this role is then referenced in `application-config.ts` as `defaultRoleUniversalIdentifier`. 换句话说： +随后，该角色的 `universalIdentifier` 会在 `application-config.ts` 中被引用为 `defaultRoleUniversalIdentifier`。 换句话说： * **\*.role.ts** 定义默认函数角色可以执行的操作。 -* **application-config.ts** points to that role so your functions inherit its permissions. +* **application-config.ts** 指向该角色，使你的函数继承其权限。 备注: @@ -386,7 +386,7 @@ The `universalIdentifier` of this role is then referenced in `application-config ### 逻辑函数的配置与入口点 -Each function file uses `defineLogicFunction()` to export a configuration with a handler and optional triggers. +每个函数文件都使用 `defineLogicFunction()` 导出包含处理程序和可选触发器的配置。 ```typescript // src/app/createPostCard.logic-function.ts @@ -551,12 +551,12 @@ const handler = async (event: RoutePayload) => { 你可以通过两种方式创建新函数： -* **Scaffolded**: Run `yarn entity:add` and choose the option to add a new logic function. 这将生成一个包含处理程序和配置的入门文件。 -* **Manual**: Create a new `*.logic-function.ts` file and use `defineLogicFunction()`, following the same pattern. +* **脚手架生成**：运行 `yarn entity:add` 并选择添加新逻辑函数的选项。 这将生成一个包含处理程序和配置的入门文件。 +* **手动**：创建一个新的 `*.logic-function.ts` 文件，并使用 `defineLogicFunction()`，遵循相同的模式。 -### Front components +### 前端组件 -Front components let you build custom React components that render within Twenty's UI. Use `defineFrontComponent()` to define components with built-in validation: +前端组件使你可以构建在 Twenty 的 UI 中渲染的自定义 React 组件。 使用 `defineFrontComponent()` 以内置校验定义组件： ```typescript // src/my-widget.front-component.tsx @@ -581,15 +581,15 @@ export default defineFrontComponent({ 关键点： -* Front components are React components that render in isolated contexts within Twenty. +* 前端组件是在 Twenty 中的隔离上下文中渲染的 React 组件。 * 使用 `*.front-component.tsx` 文件后缀以便自动检测。 -* The `component` field references your React component. -* Components are built and synced automatically during `yarn app:dev`. +* `component` 字段引用你的 React 组件。 +* 组件会在 `yarn app:dev` 期间自动构建并同步。 -You can create new front components in two ways: +你可以通过两种方式创建新的前端组件： -* **Scaffolded**: Run `yarn entity:add` and choose the option to add a new front component. -* **Manual**: Create a new `*.front-component.tsx` file and use `defineFrontComponent()`. +* **脚手架生成**：运行 `yarn entity:add` 并选择添加新前端组件的选项。 +* **手动**：创建一个新的 `*.front-component.tsx` 文件，并使用 `defineFrontComponent()`。 ### 生成的类型化客户端 @@ -614,12 +614,12 @@ const { me } = await client.query({ me: { id: true, displayName: true } }); 备注: * 你无需向生成的客户端传递 URL 或 API 密钥。 它会在运行时从 process.env 读取 `TWENTY_API_URL` 和 `TWENTY_API_KEY`。 -* The API key's permissions are determined by the role referenced in your `application-config.ts` via `defaultRoleUniversalIdentifier`. 这是你的应用逻辑函数使用的默认角色。 -* 应用可以定义角色以遵循最小权限原则。 Grant only the permissions your functions need, then point `defaultRoleUniversalIdentifier` to that role's universal identifier. +* API 密钥的权限由 `application-config.ts` 中通过 `defaultRoleUniversalIdentifier` 引用的角色决定。 这是你的应用逻辑函数使用的默认角色。 +* 应用可以定义角色以遵循最小权限原则。 仅授予函数所需的权限，然后将 `defaultRoleUniversalIdentifier` 指向该角色的通用标识符。 ### Hello World 示例 -Explore a minimal, end-to-end example that demonstrates objects, logic functions, front components, and multiple triggers [here](https://github.com/twentyhq/twenty/tree/main/packages/twenty-apps/hello-world): +在[此处](https://github.com/twentyhq/twenty/tree/main/packages/twenty-apps/hello-world)查看一个最小的端到端示例，展示对象、逻辑函数、前端组件和多种触发器： ## 手动设置（不使用脚手架）