The open alternative to Salesforce, designed for AI.
TypeScript crmcrm-systemcustomergood-first-issuegraphqlhacktoberfestjavascriptmarketingmonoreponestjsopen-sourcepostgresqlreactreactjssalestypescriptweb
i18n - docs translations (#22371)
github-actions[bot]1d7767dbc7e3
diff --git a/packages/twenty-docs/l/ar/developers/extend/apps/logic/logic-functions.mdx b/packages/twenty-docs/l/ar/developers/extend/apps/logic/logic-functions.mdxindex 8529d7adb0f..fcc3dfa2bbd 100644--- a/packages/twenty-docs/l/ar/developers/extend/apps/logic/logic-functions.mdx+++ b/packages/twenty-docs/l/ar/developers/extend/apps/logic/logic-functions.mdx@@ -411,6 +411,10 @@ const handler = async (event: PersonDestroyedEvent) => {يمكن للدالة اختيار أحدهما، أو الآخر، أو كليهما. توجد جنبًا إلى جنب مع `cronTriggerSettings` و`databaseEventTriggerSettings` و`httpRouteTriggerSettings` — النمط نفسه، والشكل نفسه.+<Note>+**العلاقة بإجراء Code الخاص بسير العمل.** يُعَد إجراء **Code** المضمَّن في منشئ سير العمل دالة منطقية بحد ذاته — حيث ينشئ Twenty واحدًا لكل خطوة Code ويعرض محرره مضمّنًا. تُستخدَم `workflowActionTriggerSettings` لتحويل هذا الكود المضمَّن لمرة واحدة إلى إجراء **قابل لإعادة الاستخدام**: عرِّف الدالة مرة واحدة في تطبيقك وستصبح قابلة للاختيار في أي سير عمل، بدلاً من نسخها ولصقها في كل خطوة Code. راجع [إجراء Code](/l/ar/user-guide/workflows/capabilities/workflow-actions#code) في دليل المستخدم لعرض منظور المستخدم النهائي.+</Note>+```ts src/logic-functions/enrich-company.logic-function.tsimport { defineLogicFunction } from 'twenty-sdk/define';import { CoreApiClient } from 'twenty-client-sdk/core';@@ -496,6 +500,77 @@ export default defineLogicFunction({});```+##### مثال كامل لإجراء سير عمل++تقبل `workflowActionTriggerSettings` أربعة حقول:++| الحقل | الغرض |+| -------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------- |+| `label` | الاسم المعروض للإجراء في منتقّي الخطوات في منشئ سير العمل. الإعداد الافتراضي هو `name` الخاص بالدالة. |+| `icon` | أيقونة تُعرَض بجانب الإجراء (اسم من `tabler-icons`، مثلًا `IconBuilding`). |+| `inputSchema` | مخطط الإدخال الغني الخاص بـ Twenty — ما يعرضه المُنشئ كحقول قابلة للضبط (مع منتقّي المتغيرات). اختياري؛ يستنتج من المعالج عند حذفه. |+| `outputSchema` | يصرِّح بالشكل الذي يعيده المعالج، بحيث **يمكن للخطوات اللاحقة أن تطابق حقول المخرجات الخاصة به**. اختياري؛ من دونه يتم كشف المخرَج كقيمة واحدة غير شفافة. |++تجميع ذلك معًا — دالّة معروضة كإجراء سير عمل، مع مخرَج مُعلَن بحيث يمكن للخطوات اللاحقة الرجوع إلى `taskId`:++```ts src/logic-functions/enrich-company.logic-function.ts+import { defineLogicFunction } from 'twenty-sdk/define';+import { jsonSchemaToInputSchema, type InputJsonSchema } from 'twenty-sdk/logic-function';+import { CoreApiClient } from 'twenty-client-sdk/core';++const inputSchema: InputJsonSchema = {+ type: 'object',+ properties: {+ companyName: { type: 'string', label: 'Company name' },+ domain: { type: 'string', label: 'Domain' },+ },+ required: ['companyName'],+};++const handler = async (params: { companyName: string; domain?: string }) => {+ const client = new CoreApiClient();++ const result = await client.mutation({+ createTask: {+ __args: {+ data: {+ title: `Enrich data for ${params.companyName}`,+ body: `Domain: ${params.domain ?? 'unknown'}`,+ },+ },+ id: true,+ },+ });++ // The keys returned here should match the `outputSchema` properties below.+ return { taskId: result.createTask.id, enriched: true };+};++export default defineLogicFunction({+ universalIdentifier: 'f47ac10b-58cc-4372-a567-0e02b2c3d479',+ name: 'enrich-company',+ description: 'Enrich a company record with external data',+ timeoutSeconds: 10,+ handler,+ workflowActionTriggerSettings: {+ label: 'Enrich Company',+ icon: 'IconBuilding',+ inputSchema: jsonSchemaToInputSchema(inputSchema),+ outputSchema: [+ {+ type: 'object',+ properties: {+ taskId: { type: 'string' },+ enriched: { type: 'boolean' },+ },+ },+ ],+ },+});+```++بمجرد تثبيت التطبيق، سيظهر **Enrich Company** في منتقّي الإجراءات في منشئ سير العمل. يعرض المُنشئ `companyName` و`domain` كحقول إدخال (كلٌّ منهما قادر على سحب القيم من الخطوات السابقة)، ويمكن للخطوات اللاحقة الرجوع إلى مخرجات الخطوة `taskId` و`enriched`.+<Note>**اكتب `description` جيدًا.** يعتمد وكلاء الذكاء الاصطناعي على حقل `description` الخاص بالدالة لتحديد وقت استخدام الأداة. كن محددًا بشأن ما تفعله الأداة ومتى ينبغي استدعاؤها.</Note>diff --git a/packages/twenty-docs/l/ar/user-guide/workflows/capabilities/use-iterator.mdx b/packages/twenty-docs/l/ar/user-guide/workflows/capabilities/use-iterator.mdxindex fc15bfa28ee..35a8b5c2798 100644--- a/packages/twenty-docs/l/ar/user-guide/workflows/capabilities/use-iterator.mdx+++ b/packages/twenty-docs/l/ar/user-guide/workflows/capabilities/use-iterator.mdx@@ -23,6 +23,12 @@ description: قم بالتكرار عبر مصفوفات السجلات لتنف3. ينتقل إلى العنصر التالي4. يكرّر حتى تتم معالجة جميع العناصر+### اختيار المصفوفة المطلوب التكرار عليها++يمكن اختيار معظم مصادر المصفوفات (بحث السجلات، حقل مصفوفة لويب هوك، مشغّل يدوي دفعي) مباشرةً من منتقي المتغيّرات.++عندما تُرجِع خطوة **Code** أو **Logic Function** *مصفوفة من المستوى الأعلى*، يظهر ناتجها في منتقي المتغيّرات كعناصر مفهرسة (`0`، `1`، `2`، …). للتكرار على المصفوفة بالكامل، اختر خيار **Whole list** لتلك الخطوة — عندها يستنتج عنصر Iterator شكل كل عنصر من القائمة تلقائيًا.+## الإعداد الأساسي### مثال: إرسال بريد إلكتروني للجميع ضمن نتائج البحث@@ -77,6 +83,8 @@ description: قم بالتكرار عبر مصفوفات السجلات لتنف| `{{iterator.currentItem.company.name}}` | اسم الشركة المرتبطة || `{{iterator.index}}` | الموضع الحالي في المصفوفة (بدءاً من 0) |+في منتقي المتغيّرات، يمكنك إما التعمّق في حقل معيّن من العنصر الحالي، أو اختيار **Use the whole item** للإشارة إلى العنصر الحالي بالكامل (`{{iterator.currentItem}}`). يكون اختيار العنصر بالكامل مفيدًا عندما تريد تمرير سجل كامل مباشرةً إلى خطوة لاحقة في خط التدفق بدلًا من إعادة بنائه حقلًا بحقل.+## أنماط شائعة### تحديث عدة سجلاتdiff --git a/packages/twenty-docs/l/ar/user-guide/workflows/capabilities/workflow-actions.mdx b/packages/twenty-docs/l/ar/user-guide/workflows/capabilities/workflow-actions.mdxindex ebf10683e51..5d01dc4bbd1 100644--- a/packages/twenty-docs/l/ar/user-guide/workflows/capabilities/workflow-actions.mdx+++ b/packages/twenty-docs/l/ar/user-guide/workflows/capabilities/workflow-actions.mdx@@ -112,7 +112,7 @@ import { VimeoEmbed } from '/snippets/vimeo-embed.mdx';**التكوين**:-* اختر مصفوفة السجلات من خطوة سابقة (مثل نتائج البحث عن السجلات، أو من مشغل يدوي مع إتاحة التنفيذ بالجملة، أو من عقدة كود)+* اختر مصفوفة السجلات من خطوة سابقة (مثل نتائج البحث عن السجلات، أو من مشغل يدوي مع إتاحة التنفيذ بالجملة، أو من عقدة كود). عندما تُرجِع خطوة Code أو دالة منطقية مصفوفة من المستوى الأعلى، حدِّد خيار **Whole list** للتكرار عبر الإخراج بالكامل.* حدد الإجراءات لتنفيذها على كل سجل في الحلقة.<Note>@@ -120,7 +120,7 @@ import { VimeoEmbed } from '/snippets/vimeo-embed.mdx';- عند استخدام تفرعات داخل المُكرِّر، تأكد من أن تتصل الخطوة الأخيرة من كل تفرع بالمُكرِّر لإغلاق الحلقة.</Note>-* الوصول إلى حقول `Current Item`: لاستخدام حقول السجل الجاري معالجته، انقر على خطوة **المُكرِّر**، ثم اختر **العنصر الحالي**. ستُعرَض قائمة الحقول المتاحة من ذلك السجل ويمكن اختيارها لاستخدامها في الإجراءات اللاحقة.+* الوصول إلى حقول `Current Item`: لاستخدام حقول السجل الجاري معالجته، انقر على خطوة **المُكرِّر**، ثم اختر **العنصر الحالي**. ستُعرَض قائمة الحقول المتاحة من ذلك السجل ويمكن اختيارها لاستخدامها في الإجراءات اللاحقة. يمكنك أيضًا تحديد **Use the whole item** لتمرير العنصر الحالي بالكامل إلى خطوة لاحقة.<VimeoEmbed videoId="1146577247" title="عرض توضيحي بالفيديو" />@@ -245,6 +245,8 @@ import { VimeoEmbed } from '/snippets/vimeo-embed.mdx';يشغل جافا سكريبت مخصص ضمن سير العمل الخاص بك.+في الخلفية، يستند كل إجراء Code إلى **دالة منطقية** خاصة به — وهي دالة TypeScript على جانب الخادم تعمل على منصة Twenty. عندما تضيف إجراء Code، يقوم Twenty بإنشاء دالة منطقية مخصَّصة لتلك الخطوة ويُظهِر محرِّرها مضمَّنًا، بحيث يكون الكود الذي تكتبه جزءًا من سير العمل.+**التكوين**:* الوصول إلى المتغيرات من الخطوات السابقة. يمكنك تعديل أسماء المتغيرات ديناميكيًا.@@ -267,6 +269,25 @@ import { VimeoEmbed } from '/snippets/vimeo-embed.mdx';انقر على أيقونة المربع في أعلى يمين محرر الكود لعرضه بملء الشاشة — فهذا مفيد لأن عرض المحرر الافتراضي محدود.</Tip>+#### إعادة استخدام دالة منطقية عبر سير عمل متعددة++إجراء Code المضمَّن ممتاز للمنطق لمرة واحدة، لكن الكود الذي يحتويه يخص تلك الخطوة الواحدة فقط. عندما تريد مشاركة المنطق نفسه عبر عدة سير عمل — أو الاحتفاظ به كمصدر مُدار بالإصدارات ضمن تطبيق — عرِّف **دالة منطقية قابلة لإعادة الاستخدام** بدلًا من نسخ ولصق الكود في كل إجراء Code.++يتم تعريف دالة منطقية مرة واحدة في تطبيق (باستخدام `defineLogicFunction` في حزمة SDK) وتُتاح في مُنشئ سير العمل عن طريق إضافة `workflowActionTriggerSettings`. بمجرد تثبيت تطبيقك، تظهر تلك الدالة كإجراء مستقل في مُنشئ سير العمل، جنبًا إلى جنب مع الإجراءات المضمَّنة. يؤدي اختيارها إلى عرض حقول الإدخال التي صرَّحتَ عنها (مع منتقي المتغيّرات، تمامًا مثل الإجراءات الأخرى) وتشغيل الكود المشترك — دون الحاجة إلى JavaScript مضمَّن.++| | إجراء Code | دالة منطقية قابلة لإعادة الاستخدام |+| ------------------- | --------------------------------------------- | ----------------------------------------------------------------------- |+| **مكان وجود الكود** | محرِّر مضمَّن، مرتبط بخطوة واحدة في سير العمل | يُعرَّف في تطبيق، مع إدارة الإصدارات في نظام التحكم في الشيفرة المصدرية |+| **إعادة الاستخدام** | يتم نسخه ولصقه لكل خطوة | يُضاف كإجراء في أي سير عمل |+| **المدخلات** | متغيّرات موصولة في المحرِّر | حقول تُعرَض من مخطط الإدخال الذي صرَّحتَ عنه |+| **الأفضل لـ** | منطق سريع خاص بسير عمل معيّن | منطق مشترك يُستخدَم عبر عدة سير عمل |++كلاهما يعمل على بيئة تشغيل الدالة المنطقية نفسها، لذا يمكن ترقية إجراء Code الذي جرَّبته مضمَّنًا لاحقًا إلى دالة منطقية قابلة لإعادة الاستخدام مع تغييرات طفيفة.++<Tip>+للاطّلاع على مرجع موجَّه للمطوّرين حول تعريف الدوال المنطقية وإتاحتها في مُنشئ سير العمل، راجع صفحة [Logic Functions](/l/ar/developers/extend/apps/logic/logic-functions) — وخصوصًا قسم **Exposing a function as an AI tool or workflow action** و `workflowActionTriggerSettings`.+</Tip>+### طلب HTTPيرسل طلبًا إلى واجهة برمجية خارجية كجزء من سير العمل الخاص بك.diff --git a/packages/twenty-docs/l/ar/user-guide/workflows/how-tos/advanced-configurations/handle-arrays-in-code-actions.mdx b/packages/twenty-docs/l/ar/user-guide/workflows/how-tos/advanced-configurations/handle-arrays-in-code-actions.mdxindex 49f919ea319..c2a6c10c86d 100644--- a/packages/twenty-docs/l/ar/user-guide/workflows/how-tos/advanced-configurations/handle-arrays-in-code-actions.mdx+++ b/packages/twenty-docs/l/ar/user-guide/workflows/how-tos/advanced-configurations/handle-arrays-in-code-actions.mdx@@ -73,9 +73,9 @@ export const main = async (params: {تعيد عقدة Code كائناً منظَّماً بدلاً من مصفوفة. في الخطوات اللاحقة، يمكنك الآن تحديد حقول فردية مثل `answer.firstname` و`answer.name` من منتقي المتغيرات.-<Note>-نعمل بنشاط على جعل التعامل مع المصفوفات أسهل في التحديثات المستقبلية.-</Note>+<Tip>+**تريد التكرار على المصفوفة بدلًا من استخراج الحقول؟** عندما تُرجِع خطوة Code أو Logic Function مصفوفة على المستوى الأعلى، يمكنك تمريرها مباشرة إلى [Iterator](/l/ar/user-guide/workflows/capabilities/use-iterator): اختر خيار **Whole list** للخطوة كمُدخل لـ Iterator، ثم ارجع إلى كل عنصر باستخدام `{{iterator.currentItem}}` داخل الحلقة. في هذه الحالة، لا تحتاج إلى إعادة هيكلة المصفوفة إلى كائن.+</Tip><Tip>انقر على أيقونة المربع في أعلى يمين محرر الكود لعرضه بملء الشاشة — فهذا مفيد لأن عرض المحرر الافتراضي محدود.diff --git a/packages/twenty-docs/l/cs/developers/extend/apps/logic/logic-functions.mdx b/packages/twenty-docs/l/cs/developers/extend/apps/logic/logic-functions.mdxindex 05378f09902..88286fc5846 100644--- a/packages/twenty-docs/l/cs/developers/extend/apps/logic/logic-functions.mdx+++ b/packages/twenty-docs/l/cs/developers/extend/apps/logic/logic-functions.mdx@@ -412,6 +412,10 @@ Logické funkce lze zpřístupnit na dvou rozhraních, z nichž každé má vlasFunkce se může rozhodnout pro jedno, druhé nebo obě. Stojí po boku `cronTriggerSettings`, `databaseEventTriggerSettings` a `httpRouteTriggerSettings` — stejný vzor, stejná struktura.+<Note>+**Vztah k akci Code ve workflow.** Vestavěná akce **Code** v tvůrci workflow je sama o sobě logická funkce — Twenty pro každý krok Code vytvoří jednu a její editor zpřístupní inline. `workflowActionTriggerSettings` je způsob, jak z jednorázového inline kódu udělat **znovupoužitelnou** akci: funkci v aplikaci nadefinujete jednou a potom je možné ji vybrat v libovolném workflow, místo aby se kopírovala do každého kroku Code. Pro pohled koncového uživatele se podívejte na [akci Code](/l/cs/user-guide/workflows/capabilities/workflow-actions#code) v uživatelské příručce.+</Note>+```ts src/logic-functions/enrich-company.logic-function.tsimport { defineLogicFunction } from 'twenty-sdk/define';import { CoreApiClient } from 'twenty-client-sdk/core';@@ -497,6 +501,77 @@ export default defineLogicFunction({});```+##### Kompletní příklad akce workflow++`workflowActionTriggerSettings` přijímá čtyři pole:++| Pole | Účel |+| -------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |+| `label` | Název zobrazený pro akci ve výběru kroků tvůrce workflow. Výchozí hodnota je `name` funkce. |+| `icon` | Ikona zobrazená vedle akce (název z `tabler-icons`, např. `IconBuilding`). |+| `inputSchema` | Rozšířený `InputSchema` Twenty — to, co tvůrce zobrazuje jako konfigurovatelná pole (s výběrem proměnných). Volitelné; pokud je vynecháno, odvodí se z handleru. |+| `outputSchema` | Definuje strukturu, kterou handler vrací, aby na **jeho výstupní pole mohly navazující kroky mapovat**. Volitelné; bez něj je výstup zpřístupněn jako jedna neprůhledná hodnota. |++Dohromady — funkce zpřístupněná jako akce workflow s deklarovaným výstupem, aby se na `taskId` mohly odkazovat pozdější kroky:++```ts src/logic-functions/enrich-company.logic-function.ts+import { defineLogicFunction } from 'twenty-sdk/define';+import { jsonSchemaToInputSchema, type InputJsonSchema } from 'twenty-sdk/logic-function';+import { CoreApiClient } from 'twenty-client-sdk/core';++const inputSchema: InputJsonSchema = {+ type: 'object',+ properties: {+ companyName: { type: 'string', label: 'Company name' },+ domain: { type: 'string', label: 'Domain' },+ },+ required: ['companyName'],+};++const handler = async (params: { companyName: string; domain?: string }) => {+ const client = new CoreApiClient();++ const result = await client.mutation({+ createTask: {+ __args: {+ data: {+ title: `Enrich data for ${params.companyName}`,+ body: `Domain: ${params.domain ?? 'unknown'}`,+ },+ },+ id: true,+ },+ });++ // The keys returned here should match the `outputSchema` properties below.+ return { taskId: result.createTask.id, enriched: true };+};++export default defineLogicFunction({+ universalIdentifier: 'f47ac10b-58cc-4372-a567-0e02b2c3d479',+ name: 'enrich-company',+ description: 'Enrich a company record with external data',+ timeoutSeconds: 10,+ handler,+ workflowActionTriggerSettings: {+ label: 'Enrich Company',+ icon: 'IconBuilding',+ inputSchema: jsonSchemaToInputSchema(inputSchema),+ outputSchema: [+ {+ type: 'object',+ properties: {+ taskId: { type: 'string' },+ enriched: { type: 'boolean' },+ },+ },+ ],+ },+});+```++Jakmile je aplikace nainstalovaná, **Enrich Company** se zobrazí ve výběru akcí tvůrce workflow. Tvůrce zobrazí `companyName` a `domain` jako vstupní pole (každé z nich může získávat hodnoty z předchozích kroků) a následující kroky se mohou odkazovat na výstupy kroku `taskId` a `enriched`.+<Note>**Napište kvalitní `description`.** Agenti AI se spoléhají na pole funkce `description` při rozhodování, kdy nástroj použít. Buďte konkrétní ohledně toho, co nástroj dělá a kdy se má volat.</Note>diff --git a/packages/twenty-docs/l/cs/user-guide/workflows/capabilities/use-iterator.mdx b/packages/twenty-docs/l/cs/user-guide/workflows/capabilities/use-iterator.mdxindex 672ecacf48d..5f98eab8364 100644--- a/packages/twenty-docs/l/cs/user-guide/workflows/capabilities/use-iterator.mdx+++ b/packages/twenty-docs/l/cs/user-guide/workflows/capabilities/use-iterator.mdx@@ -23,6 +23,12 @@ Iterátor jako vstup očekává **pole**. Poté:3. Přejde na další položku4. Opakuje, dokud nejsou zpracovány všechny položky+### Výběr pole, přes které se bude iterovat++Většinu zdrojů polí (Search Records, vícehodnotové pole ve webhooku, hromadný ruční spouštěč) lze vybrat přímo v nástroji pro výběr proměnných.++Když krok **Code** nebo **Logic Function** vrátí *pole nejvyšší úrovně*, jeho výstup se v nástroji pro výběr proměnných zobrazí jako indexované položky (`0`, `1`, `2`, …). Chcete-li iterovat přes celé pole, vyberte u daného kroku možnost **Whole list** — Iterator pak automaticky odvodí strukturu každé položky ze seznamu.+## Základní nastavení### Příklad: Odeslání e-mailu všem ve výsledcích hledání@@ -77,6 +83,8 @@ Uvnitř iterátoru použijte `{{iterator.currentItem}}` pro přístup k aktuáln| `{{iterator.currentItem.company.name}}` | Název související společnosti || `{{iterator.index}}` | Aktuální pozice v poli (od 0) |+V nástroji pro výběr proměnných můžete buď přejít do konkrétního pole aktuální položky, nebo zvolit **Use the whole item** pro odkaz na celou aktuální položku (`{{iterator.currentItem}}`). Výběr celé položky je užitečný, když chcete předat celý záznam přímo do následujícího kroku, místo abyste ho znovu sestavovali pole po poli.+## Běžné vzory### Aktualizace více záznamůdiff --git a/packages/twenty-docs/l/cs/user-guide/workflows/capabilities/workflow-actions.mdx b/packages/twenty-docs/l/cs/user-guide/workflows/capabilities/workflow-actions.mdxindex 96fa63d5043..d4e5bc7a989 100644--- a/packages/twenty-docs/l/cs/user-guide/workflows/capabilities/workflow-actions.mdx+++ b/packages/twenty-docs/l/cs/user-guide/workflows/capabilities/workflow-actions.mdx@@ -112,7 +112,7 @@ Vytvoří nový záznam nebo aktualizuje existující na základě kritérií sh**Konfigurace**:-* Vyberte pole záznamů z předchozího kroku (např. výsledky z vyhledávání záznamů, z ručního spouštěče s hromadnou dostupností, z uzlu kódu)+* Vyberte pole záznamů z předchozího kroku (např. výsledky z vyhledávání záznamů, z ručního spouštěče s hromadnou dostupností, z uzlu kódu). Když krok Code nebo Logic Function vrátí pole na nejvyšší úrovni, vyberte možnost **Whole list**, abyste procházeli celý výstup.* Definujte akce, které budou provedeny na každém záznamu v cyklu.<Note>@@ -120,7 +120,7 @@ Vytvoří nový záznam nebo aktualizuje existující na základě kritérií sh- Při používání větví uvnitř iterátoru se ujistěte, že poslední krok každé větve se vrací zpět do iterátoru, aby se smyčka uzavřela.</Note>-* Přístup k polím `Current Item`: chcete-li použít pole ze záznamu, který se právě zpracovává, klikněte na krok **Iterator** a vyberte **Current item**. Zobrazí se seznam dostupných polí z daného záznamu a můžete je vybrat k použití v následujících akcích.+* Přístup k polím `Current Item`: chcete-li použít pole ze záznamu, který se právě zpracovává, klikněte na krok **Iterator** a vyberte **Current item**. Zobrazí se seznam dostupných polí z daného záznamu a můžete je vybrat k použití v následujících akcích. Můžete také vybrat **Use the whole item**, abyste předali celou aktuální položku do následujícího kroku.<VimeoEmbed videoId="1146577247" title="Ukázka videa" />@@ -245,6 +245,8 @@ Pole nelze nastavit jako povinná.Spouští vlastní JavaScript ve vašem pracovním postupu.+Na pozadí je každá akce Code podpořena vlastní **logickou funkcí** — serverovou funkcí v TypeScriptu, která běží na platformě Twenty. Když přidáte akci Code, Twenty vytvoří pro tento krok vyhrazenou logickou funkci a zobrazí její editor přímo inline, takže kód, který napíšete, zůstává u pracovního postupu.+**Konfigurace**:* Přístup k proměnným z předchozích kroků. Názvy proměnných můžete upravovat dynamicky.@@ -267,6 +269,25 @@ Pokud potřebujete ve svém kódu použít externí klíče API, musíte je zadaKlikněte na čtvercovou ikonu vpravo nahoře v editoru kódu a zobrazte jej na celou obrazovku — hodí se to, protože výchozí šířka editoru je omezená.</Tip>+#### Znovupoužití logické funkce napříč pracovními postupy++Inline akce Code je skvělá pro jednorázovou logiku, ale kód, který obsahuje, patří pouze tomuto jedinému kroku. Když chcete sdílet stejnou logiku napříč několika pracovními postupy — nebo ji udržovat jako verzovaný zdrojový kód v aplikaci — definujte **znovupoužitelnou logickou funkci** místo kopírování a vkládání kódu do každé akce Code.++Logická funkce je definována jednou v aplikaci (pomocí SDK `defineLogicFunction`) a zpřístupněna v nástroji pro tvorbu pracovních postupů přidáním `workflowActionTriggerSettings`. Jakmile je vaše aplikace nainstalována, tato funkce se objeví jako samostatná akce v nástroji pro tvorbu pracovních postupů vedle vestavěných akcí. Její výběr vykreslí vstupní pole, která jste deklarovali (s výběry proměnných, stejně jako u jiných akcí), a spustí váš sdílený kód — není potřeba žádný inline JavaScript.++| | Akce Code | Znovupoužitelná logická funkce |+| ---------------- | ------------------------------------------------------ | ----------------------------------------------------------------- |+| **Kde kód žije** | Inline editor, vázaný na jeden krok pracovního postupu | Definována v aplikaci, verzovaná v systému správy zdrojového kódu |+| **Znovupoužití** | Kopírováno a vkládáno pro každý krok | Přidána jako akce v libovolném pracovním postupu |+| **Vstupy** | Proměnné zapojené v editoru | Pole vykreslená z vámi deklarovaného vstupního schématu |+| **Vhodné pro** | Rychlá logika specifická pro daný pracovní postup | Sdílená logika používaná napříč více pracovními postupy |++Obě běží ve stejném běhovém prostředí logických funkcí, takže akci Code, kterou jste prototypovali inline, lze později povýšit na znovupoužitelnou logickou funkci s minimálními změnami.++<Tip>+Referenční dokumentaci pro vývojáře k definování logických funkcí a jejich zpřístupnění v nástroji pro tvorbu pracovních postupů najdete v [Logic Functions](/l/cs/developers/extend/apps/logic/logic-functions) — zejména v sekci **Exposing a function as an AI tool or workflow action** a `workflowActionTriggerSettings`.+</Tip>+### HTTP požadavekOdešle požadavek na externí API v rámci vašeho pracovního postupu.diff --git a/packages/twenty-docs/l/cs/user-guide/workflows/how-tos/advanced-configurations/handle-arrays-in-code-actions.mdx b/packages/twenty-docs/l/cs/user-guide/workflows/how-tos/advanced-configurations/handle-arrays-in-code-actions.mdxindex 6d7dca6a256..f251bebb1fe 100644--- a/packages/twenty-docs/l/cs/user-guide/workflows/how-tos/advanced-configurations/handle-arrays-in-code-actions.mdx+++ b/packages/twenty-docs/l/cs/user-guide/workflows/how-tos/advanced-configurations/handle-arrays-in-code-actions.mdx@@ -73,9 +73,9 @@ export const main = async (params: {Uzel Code vrátí místo pole strukturovaný objekt. V následujících krocích nyní můžete ve výběru proměnných vybrat jednotlivá pole, jako `answer.firstname` a `answer.name`.-<Note>-Aktivně pracujeme na tom, aby bylo zacházení s poli v budoucích aktualizacích snazší.-</Note>+<Tip>+**Chcete místo rozbalování polí iterovat přímo přes pole?** Když krok Code nebo Logic Function vrátí pole na nejvyšší úrovni, můžete ho předat přímo do [Iteratoru](/l/cs/user-guide/workflows/capabilities/use-iterator): jako vstup Iteratoru vyberte možnost kroku **Whole list** a uvnitř smyčky pak na každou položku odkazujte pomocí `{{iterator.currentItem}}`. V takovém případě nemusíte pole převádět na objekt.+</Tip><Tip>Klikněte na čtvercovou ikonu vpravo nahoře v editoru kódu a zobrazte jej na celou obrazovku — hodí se to, protože výchozí šířka editoru je omezená.diff --git a/packages/twenty-docs/l/de/developers/extend/apps/logic/logic-functions.mdx b/packages/twenty-docs/l/de/developers/extend/apps/logic/logic-functions.mdxindex dd17043d9dd..8acd4092d32 100644--- a/packages/twenty-docs/l/de/developers/extend/apps/logic/logic-functions.mdx+++ b/packages/twenty-docs/l/de/developers/extend/apps/logic/logic-functions.mdx@@ -411,6 +411,10 @@ Logikfunktionen können auf zwei Oberflächen verfügbar gemacht werden, jeweilsEine Funktion kann sich für eine, die andere oder beide entscheiden. Sie stehen neben `cronTriggerSettings`, `databaseEventTriggerSettings` und `httpRouteTriggerSettings` — gleiches Muster, gleiche Struktur.+<Note>+**Beziehung zur Code-Aktion im Workflow.** Die integrierte **Code**-Aktion im Workflow-Builder ist selbst eine Logikfunktion – Twenty erstellt für jeden Code-Schritt eine Logikfunktion und stellt deren Editor inline bereit. `workflowActionTriggerSettings` ist die Art und Weise, wie Sie diesen einmaligen Inline-Code in eine **wiederverwendbare** Aktion verwandeln: Definieren Sie die Funktion einmal in Ihrer App, und sie wird in jedem Workflow auswählbar, anstatt in jeden Code-Schritt kopiert zu werden. Siehe die [Code-Aktion](/l/de/user-guide/workflows/capabilities/workflow-actions#code) im Benutzerhandbuch für die Endbenutzeransicht.+</Note>+```ts src/logic-functions/enrich-company.logic-function.tsimport { defineLogicFunction } from 'twenty-sdk/define';import { CoreApiClient } from 'twenty-client-sdk/core';@@ -496,6 +500,77 @@ export default defineLogicFunction({});```+##### Ein vollständiges Beispiel für eine Workflow-Aktion++`workflowActionTriggerSettings` akzeptiert vier Felder:++| Feld | Zweck |+| -------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |+| `label` | Name, der für die Aktion in der Schritt-Auswahl des Workflow-Builders angezeigt wird. Standardmäßig der Funktions-`name`. |+| `icon` | Symbol, das neben der Aktion angezeigt wird (ein `tabler-icons`-Name, z. B. `IconBuilding`). |+| `inputSchema` | Twentys umfangreiches `InputSchema` – das, was der Builder als konfigurierbare Felder (mit Variablen-Auswählern) rendert. Optional; wird aus dem Handler abgeleitet, wenn es weggelassen wird. |+| `outputSchema` | Deklariert die Struktur, die der Handler zurückgibt, sodass **nachfolgende Schritte auf seine Ausgabefelder abbilden können**. Optional; ohne dieses Schema wird die Ausgabe als einzelner undurchsichtiger Wert bereitgestellt. |++Alles zusammen – eine Funktion, die als Workflow-Aktion bereitgestellt wird, mit einer deklarierten Ausgabe, damit spätere Schritte auf `taskId` verweisen können:++```ts src/logic-functions/enrich-company.logic-function.ts+import { defineLogicFunction } from 'twenty-sdk/define';+import { jsonSchemaToInputSchema, type InputJsonSchema } from 'twenty-sdk/logic-function';+import { CoreApiClient } from 'twenty-client-sdk/core';++const inputSchema: InputJsonSchema = {+ type: 'object',+ properties: {+ companyName: { type: 'string', label: 'Company name' },+ domain: { type: 'string', label: 'Domain' },+ },+ required: ['companyName'],+};++const handler = async (params: { companyName: string; domain?: string }) => {+ const client = new CoreApiClient();++ const result = await client.mutation({+ createTask: {+ __args: {+ data: {+ title: `Enrich data for ${params.companyName}`,+ body: `Domain: ${params.domain ?? 'unknown'}`,+ },+ },+ id: true,+ },+ });++ // The keys returned here should match the `outputSchema` properties below.+ return { taskId: result.createTask.id, enriched: true };+};++export default defineLogicFunction({+ universalIdentifier: 'f47ac10b-58cc-4372-a567-0e02b2c3d479',+ name: 'enrich-company',+ description: 'Enrich a company record with external data',+ timeoutSeconds: 10,+ handler,+ workflowActionTriggerSettings: {+ label: 'Enrich Company',+ icon: 'IconBuilding',+ inputSchema: jsonSchemaToInputSchema(inputSchema),+ outputSchema: [+ {+ type: 'object',+ properties: {+ taskId: { type: 'string' },+ enriched: { type: 'boolean' },+ },+ },+ ],+ },+});+```++Sobald die App installiert ist, erscheint **Enrich Company** im Aktionswähler des Workflow-Builders. Der Builder rendert `companyName` und `domain` als Eingabefelder (die jeweils Werte aus vorherigen Schritten beziehen können), und nachgelagerte Schritte können auf die `taskId`- und `enriched`-Ausgaben des Schritts verweisen.+<Note>**Schreiben Sie eine gute `description`.** KI-Agenten verlassen sich auf das `description`-Feld der Funktion, um zu entscheiden, wann das Tool verwendet werden soll. Seien Sie konkret darin, was das Tool tut und wann es aufgerufen werden soll.</Note>diff --git a/packages/twenty-docs/l/de/user-guide/workflows/capabilities/use-iterator.mdx b/packages/twenty-docs/l/de/user-guide/workflows/capabilities/use-iterator.mdxindex f1a3fe5a6c6..8794380ee46 100644--- a/packages/twenty-docs/l/de/user-guide/workflows/capabilities/use-iterator.mdx+++ b/packages/twenty-docs/l/de/user-guide/workflows/capabilities/use-iterator.mdx@@ -23,6 +23,12 @@ Iterator erwartet ein **Array** als Eingabe. Dann:3. Wechselt zum nächsten Element4. Wiederholt sich, bis alle Elemente verarbeitet sind+### Auswählen des Arrays, über das iteriert werden soll++Die meisten Array-Quellen (Search Records, ein Webhook-Array-Feld, ein Bulk Manual Trigger) können direkt im Variablen-Auswahldialog ausgewählt werden.++Wenn ein **Code**- oder **Logic Function**-Schritt ein *Top-Level-Array* zurückgibt, erscheint dessen Ausgabe im Variablen-Auswahldialog als indizierte Einträge (`0`, `1`, `2`, …). Um über das Array als Ganzes zu iterieren, wähle für diesen Schritt die Option **Whole list** – der Iterator leitet dann die Struktur jedes Elements automatisch aus der Liste ab.+## Grundlegende Einrichtung### Beispiel: E-Mail an alle in den Suchergebnissen@@ -77,6 +83,8 @@ Im Iterator verwenden Sie `{{iterator.currentItem}}`, um auf den aktuellen Daten| `{{iterator.currentItem.company.name}}` | Name des zugehörigen Unternehmens || `{{iterator.index}}` | Aktuelle Position im Array (0-basiert) |+Im Variablen-Auswahldialog kannst du entweder in ein bestimmtes Feld des aktuellen Elements hineinnavigieren oder **Use the whole item** auswählen, um auf das gesamte aktuelle Element zu verweisen (`{{iterator.currentItem}}`). Das Auswählen des gesamten Elements ist praktisch, wenn du einen vollständigen Datensatz direkt an einen nachgelagerten Schritt übergeben möchtest, anstatt ihn Feld für Feld neu aufzubauen.+## Häufige Muster### Mehrere Datensätze aktualisierendiff --git a/packages/twenty-docs/l/de/user-guide/workflows/capabilities/workflow-actions.mdx b/packages/twenty-docs/l/de/user-guide/workflows/capabilities/workflow-actions.mdxindex 59cbdce5896..52d8bd65ac8 100644--- a/packages/twenty-docs/l/de/user-guide/workflows/capabilities/workflow-actions.mdx+++ b/packages/twenty-docs/l/de/user-guide/workflows/capabilities/workflow-actions.mdx@@ -112,7 +112,7 @@ Erstellt einen neuen Datensatz oder aktualisiert einen vorhandenen anhand von Ü**Konfiguration**:-* Wählen Sie ein Array von Datensätzen aus einem vorherigen Schritt (z.B. Ergebnisse von Suchdatensätzen, aus einem manuellen Trigger mit Bulk-Verfügbarkeit, von einem Codeknoten)+* Wählen Sie das Array von Datensätzen aus einem vorherigen Schritt aus (z. B. Ergebnisse aus Search Records, aus einem manuellen Auslöser mit Bulk-Verfügbarkeit, aus einem Code-Node). Wenn ein Code- oder Logikfunktions-Schritt ein Top-Level-Array zurückgibt, wählen Sie die Option **Whole list**, um über die gesamte Ausgabe zu iterieren.* Definieren Sie die Aktionen, die für jeden Datensatz in der Schleife ausgeführt werden sollen.<Note>@@ -120,7 +120,7 @@ Erstellt einen neuen Datensatz oder aktualisiert einen vorhandenen anhand von Ü- Wenn Sie Zweige innerhalb eines Iterators verwenden, stellen Sie sicher, dass sich der letzte Schritt jedes Zweiges mit dem Iterator verbindet, um die Schleife zu schließen.</Note>-* Zugriff auf `Aktuelle Item` Felder: Um Felder aus dem aktuell verarbeiteten Datensatz zu verwenden, klicke auf den **Iterator** Schritt, dann wähle **Aktuelles Iterator**. Die Liste der verfügbaren Felder aus diesem Datensatz wird angezeigt und kann für die Verwendung in folgenden Aktionen ausgewählt werden.+* Zugriff auf `Aktuelle Item` Felder: Um Felder aus dem aktuell verarbeiteten Datensatz zu verwenden, klicke auf den **Iterator** Schritt, dann wähle **Aktuelles Iterator**. Die Liste der verfügbaren Felder aus diesem Datensatz wird angezeigt und kann für die Verwendung in folgenden Aktionen ausgewählt werden. Sie können auch **Use the whole item** auswählen, um das gesamte aktuelle Element an einen nachgelagerten Schritt zu übergeben.<VimeoEmbed videoId="1146577247" title="Video-Demo" />@@ -245,6 +245,8 @@ Die Felder können nicht obligatorisch gemacht werden.Führt benutzerdefiniertes JavaScript in Ihrem Workflow aus.+Im Hintergrund wird jede Code-Aktion von ihrer eigenen **Logikfunktion** unterstützt – einer serverseitigen TypeScript-Funktion, die auf der Twenty-Plattform ausgeführt wird. Wenn Sie eine Code-Aktion hinzufügen, erstellt Twenty eine dedizierte Logikfunktion für diesen Schritt und stellt deren Editor inline bereit, sodass der von Ihnen geschriebene Code zusammen mit dem Workflow gespeichert wird.+**Konfiguration**:* Greifen Sie auf Variablen aus vorherigen Schritten zu. Sie können die Namen der Variablen dynamisch bearbeiten.@@ -267,6 +269,25 @@ Wenn Sie externe API-Schlüssel in Ihrem Code verwenden müssen, müssen Sie dieKlicken Sie auf das quadratische Symbol oben rechts im Code-Editor, um es im Vollbildmodus anzuzeigen – hilfreich, da die Standardbreite des Editors begrenzt ist.</Tip>+#### Eine Logikfunktion in mehreren Workflows wiederverwenden++Die Inline-Code-Aktion ist ideal für einmalige Logik, aber der darin enthaltene Code gehört zu genau diesem einen Schritt. Wenn Sie dieselbe Logik über mehrere Workflows hinweg teilen oder sie als versionierten Quellcode in einer App pflegen möchten, definieren Sie eine **wiederverwendbare Logikfunktion**, anstatt Code in jede Code-Aktion zu kopieren und einzufügen.++Eine Logikfunktion wird einmal in einer App definiert (mithilfe des SDK-Befehls `defineLogicFunction`) und durch Hinzufügen von `workflowActionTriggerSettings` im Workflow-Builder verfügbar gemacht. Sobald Ihre App installiert ist, erscheint diese Funktion als eigene Aktion im Workflow-Builder, neben den eingebauten Aktionen. Wenn Sie sie auswählen, werden die von Ihnen deklarierten Eingabefelder angezeigt (mit Variablen-Auswahl, genau wie bei anderen Aktionen) und Ihr geteilter Code wird ausgeführt – kein Inline-JavaScript erforderlich.++| | Code-Aktion | Wiederverwendbare Logikfunktion |+| -------------------------- | ----------------------------------------------------------- | ------------------------------------------------------------------ |+| **Wo der Code liegt** | Inline-Editor, an einen einzelnen Workflow-Schritt gebunden | In einer App definiert, im Versionskontrollsystem versioniert |+| **Wiederverwendung** | Pro Schritt kopiert und eingefügt | Als Aktion in jedem Workflow hinzugefügt |+| **Eingaben** | Variablen, die im Editor verdrahtet werden | Felder, die aus Ihrem deklarierten Eingabe-Schema gerendert werden |+| **Am besten geeignet für** | Schnelle, Workflow-spezifische Logik | Gemeinsam genutzte Logik, die in mehreren Workflows verwendet wird |++Beide laufen auf derselben Logikfunktions-Laufzeit, sodass eine Code-Aktion, die Sie inline prototypisiert haben, später mit minimalen Änderungen in eine wiederverwendbare Logikfunktion überführt werden kann.++<Tip>+Die entwicklerorientierte Referenz zur Definition von Logikfunktionen und deren Bereitstellung im Workflow-Builder finden Sie unter [Logic Functions](/l/de/developers/extend/apps/logic/logic-functions) – insbesondere im Abschnitt **Exposing a function as an AI tool or workflow action** und bei `workflowActionTriggerSettings`.+</Tip>+### HTTP-AnfrageSendet eine Anfrage an eine externe API als Teil Ihres Workflows.diff --git a/packages/twenty-docs/l/de/user-guide/workflows/how-tos/advanced-configurations/handle-arrays-in-code-actions.mdx b/packages/twenty-docs/l/de/user-guide/workflows/how-tos/advanced-configurations/handle-arrays-in-code-actions.mdxindex 8cb02e7282f..0b19a106fa0 100644--- a/packages/twenty-docs/l/de/user-guide/workflows/how-tos/advanced-configurations/handle-arrays-in-code-actions.mdx+++ b/packages/twenty-docs/l/de/user-guide/workflows/how-tos/advanced-configurations/handle-arrays-in-code-actions.mdx@@ -73,9 +73,9 @@ export const main = async (params: {Der Code-Knoten gibt statt eines Arrays ein strukturiertes Objekt zurück. In den folgenden Schritten können Sie nun einzelne Felder wie `answer.firstname` und `answer.name` aus der Variablenauswahl auswählen.-<Note>-Wir arbeiten aktiv daran, die Arbeit mit Arrays in zukünftigen Updates zu vereinfachen.-</Note>+<Tip>+**Möchten Sie über das Array iterieren, anstatt Felder zu extrahieren?** Wenn ein Code- oder Logikfunktionsschritt ein Array auf oberster Ebene zurückgibt, können Sie es direkt in einen [Iterator](/l/de/user-guide/workflows/capabilities/use-iterator) einspeisen: Wählen Sie die Option **Whole list** des Schritts als Eingabe des Iterators und verweisen Sie dann innerhalb der Schleife mit `{{iterator.currentItem}}` auf jedes Element. In diesem Fall müssen Sie das Array nicht in ein Objekt umstrukturieren.+</Tip><Tip>Klicken Sie auf das quadratische Symbol oben rechts im Code-Editor, um ihn im Vollbild anzuzeigen — hilfreich, da die Standardbreite des Editors begrenzt ist.diff --git a/packages/twenty-docs/l/es/developers/extend/apps/logic/logic-functions.mdx b/packages/twenty-docs/l/es/developers/extend/apps/logic/logic-functions.mdxindex 0832a15f5e4..54f87802579 100644--- a/packages/twenty-docs/l/es/developers/extend/apps/logic/logic-functions.mdx+++ b/packages/twenty-docs/l/es/developers/extend/apps/logic/logic-functions.mdx@@ -412,6 +412,10 @@ Las funciones lógicas pueden exponerse en dos ámbitos, cada uno con su propioUna función puede optar por una, por la otra o por ambas. Se ubican junto a `cronTriggerSettings`, `databaseEventTriggerSettings` y `httpRouteTriggerSettings` — mismo patrón, misma estructura.+<Note>+**Relación con la acción Code del flujo de trabajo.** La acción integrada **Code** en el generador de flujos de trabajo es en sí misma una función lógica: Twenty crea una por cada paso de Code y expone su editor en línea. `workflowActionTriggerSettings` es la forma de convertir ese código puntual en línea en una acción **reutilizable**: defines la función una vez en tu aplicación y se vuelve seleccionable en cualquier flujo de trabajo, en lugar de copiarla y pegarla en cada paso de Code. Consulta la [acción Code](/l/es/user-guide/workflows/capabilities/workflow-actions#code) en la guía del usuario para ver la perspectiva del usuario final.+</Note>+```ts src/logic-functions/enrich-company.logic-function.tsimport { defineLogicFunction } from 'twenty-sdk/define';import { CoreApiClient } from 'twenty-client-sdk/core';@@ -497,6 +501,77 @@ export default defineLogicFunction({});```+##### Ejemplo completo de una acción de flujo de trabajo++`workflowActionTriggerSettings` acepta cuatro campos:++| Campo | Propósito |+| -------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |+| `label` | Nombre que se muestra para la acción en el selector de pasos del generador de flujos de trabajo. De manera predeterminada, usa el `name` de la función. |+| `icon` | Icono que se muestra junto a la acción (un nombre de `tabler-icons`, por ejemplo `IconBuilding`). |+| `inputSchema` | El completo `InputSchema` de Twenty: lo que el generador representa como campos configurables (con selectores de variables). Opcional; se infiere a partir del controlador cuando se omite. |+| `outputSchema` | Declara la forma que devuelve el controlador, para que **los pasos posteriores puedan asignar campos a su salida**. Opcional; sin él, la salida se expone como un único valor opaco. |++Uniéndolo todo: una función expuesta como una acción de flujo de trabajo, con una salida declarada para que los pasos posteriores puedan hacer referencia a `taskId`:++```ts src/logic-functions/enrich-company.logic-function.ts+import { defineLogicFunction } from 'twenty-sdk/define';+import { jsonSchemaToInputSchema, type InputJsonSchema } from 'twenty-sdk/logic-function';+import { CoreApiClient } from 'twenty-client-sdk/core';++const inputSchema: InputJsonSchema = {+ type: 'object',+ properties: {+ companyName: { type: 'string', label: 'Company name' },+ domain: { type: 'string', label: 'Domain' },+ },+ required: ['companyName'],+};++const handler = async (params: { companyName: string; domain?: string }) => {+ const client = new CoreApiClient();++ const result = await client.mutation({+ createTask: {+ __args: {+ data: {+ title: `Enrich data for ${params.companyName}`,+ body: `Domain: ${params.domain ?? 'unknown'}`,+ },+ },+ id: true,+ },+ });++ // The keys returned here should match the `outputSchema` properties below.+ return { taskId: result.createTask.id, enriched: true };+};++export default defineLogicFunction({+ universalIdentifier: 'f47ac10b-58cc-4372-a567-0e02b2c3d479',+ name: 'enrich-company',+ description: 'Enrich a company record with external data',+ timeoutSeconds: 10,+ handler,+ workflowActionTriggerSettings: {+ label: 'Enrich Company',+ icon: 'IconBuilding',+ inputSchema: jsonSchemaToInputSchema(inputSchema),+ outputSchema: [+ {+ type: 'object',+ properties: {+ taskId: { type: 'string' },+ enriched: { type: 'boolean' },+ },+ },+ ],+ },+});+```++Una vez que la aplicación está instalada, **Enrich Company** aparece en el selector de acciones del generador de flujos de trabajo. El generador representa `companyName` y `domain` como campos de entrada (cada uno puede extraer valores de pasos anteriores), y los pasos posteriores pueden hacer referencia a las salidas `taskId` y `enriched` de ese paso.+<Note>**Escribe una buena `description`.** Los agentes de IA dependen del campo `description` de la función para decidir cuándo usar la herramienta. Sé específico acerca de lo que hace la herramienta y cuándo debe invocarse.</Note>diff --git a/packages/twenty-docs/l/es/user-guide/workflows/capabilities/use-iterator.mdx b/packages/twenty-docs/l/es/user-guide/workflows/capabilities/use-iterator.mdxindex 9b122d9e6a9..89ece81df60 100644--- a/packages/twenty-docs/l/es/user-guide/workflows/capabilities/use-iterator.mdx+++ b/packages/twenty-docs/l/es/user-guide/workflows/capabilities/use-iterator.mdx@@ -23,6 +23,12 @@ El iterador espera un **array** como entrada. Luego:3. Pasa al siguiente elemento4. Repite hasta que se procesen todos los elementos+### Seleccionar el array sobre el que iterar++La mayoría de las fuentes de arrays (Search Records, un campo de array de un webhook, un Bulk manual trigger) se pueden seleccionar directamente en el selector de variables.++Cuando un paso de **Code** o **Logic Function** devuelve un *array de nivel superior*, su salida aparece en el selector de variables como entradas indexadas (`0`, `1`, `2`, …). Para iterar sobre el array como un todo, selecciona la opción **Whole list** para ese paso; el Iterator entonces infiere automáticamente la estructura de cada elemento a partir de la lista.+## Configuración básica### Ejemplo: enviar un correo electrónico a todos en los resultados de búsqueda@@ -77,6 +83,8 @@ Dentro del iterador, usa `{{iterator.currentItem}}` para acceder al registro act| `{{iterator.currentItem.company.name}}` | Nombre de la empresa relacionada || `{{iterator.index}}` | Posición actual en el array (comenzando en 0) |+En el selector de variables, puedes profundizar en un campo específico del elemento actual, o elegir **Use the whole item** para hacer referencia a todo el elemento actual (`{{iterator.currentItem}}`). Seleccionar el elemento completo es útil cuando quieres pasar un registro completo directamente a un paso posterior en lugar de reconstruirlo campo por campo.+## Patrones comunes### Actualizar varios registrosdiff --git a/packages/twenty-docs/l/es/user-guide/workflows/capabilities/workflow-actions.mdx b/packages/twenty-docs/l/es/user-guide/workflows/capabilities/workflow-actions.mdxindex 02ba4890597..097120bdc12 100644--- a/packages/twenty-docs/l/es/user-guide/workflows/capabilities/workflow-actions.mdx+++ b/packages/twenty-docs/l/es/user-guide/workflows/capabilities/workflow-actions.mdx@@ -112,7 +112,7 @@ Crea un registro nuevo o actualiza uno existente según criterios de coincidenci**Configuración**:-* Seleccione el array de registros de un paso anterior (p. ej., resultados de Buscar registros, de un disparador Manual con disponibilidad Masiva, de un nodo de código)+* Seleccione el array de registros de un paso anterior (p. ej., resultados de Buscar registros, de un disparador Manual con disponibilidad Masiva, de un nodo de código). Cuando un paso de Code o de una función lógica devuelve un array de nivel superior, selecciona la opción **Lista completa** para iterar sobre toda la salida.* Defina las acciones a realizar en cada registro en el bucle.<Note>@@ -120,7 +120,7 @@ Crea un registro nuevo o actualiza uno existente según criterios de coincidenci- Al usar ramas dentro de un iterador, asegúrese de que el último paso de cada rama se conecte de nuevo al iterador para cerrar el bucle.</Note>-* Acceda a los campos de `Elemento actual`: para usar campos del registro que se está procesando, haga clic en el paso **Iterador** y luego seleccione **Elemento actual**. Se mostrará la lista de campos disponibles de ese registro y podrá seleccionarlos para usarlos en acciones posteriores.+* Acceda a los campos de `Elemento actual`: para usar campos del registro que se está procesando, haga clic en el paso **Iterador** y luego seleccione **Elemento actual**. Se mostrará la lista de campos disponibles de ese registro y podrá seleccionarlos para usarlos en acciones posteriores. También puedes seleccionar **Usar el elemento completo** para pasar el elemento actual completo a un paso posterior.<VimeoEmbed videoId="1146577247" title="Demostración en video" />@@ -245,6 +245,8 @@ Los campos no se pueden hacer obligatorios.Ejecuta JavaScript personalizado dentro de su flujo de trabajo.+Detrás de escena, cada acción de código está respaldada por su propia **función lógica** —una función TypeScript del lado del servidor que se ejecuta en la plataforma Twenty—. Cuando agregas una acción de código, Twenty crea una función lógica dedicada para ese paso y muestra su editor en línea, de modo que el código que escribes queda asociado al flujo de trabajo.+**Configuración**:* Acceda a variables de pasos anteriores. Puede editar los nombres de las variables dinámicamente.@@ -267,6 +269,25 @@ Si necesita usar claves de API externas en su código, debe introducirlas directHaga clic en el icono cuadrado en la parte superior derecha del editor de código para mostrarlo en pantalla completa — es útil, ya que el ancho predeterminado del editor es limitado.</Tip>+#### Reutilizar una función lógica en distintos flujos de trabajo++La acción de código en línea es ideal para lógica puntual, pero el código que contiene pertenece a ese único paso. Cuando quieras compartir la misma lógica en varios flujos de trabajo —o mantenerla como código fuente versionado en una app—, define una **función lógica reutilizable** en lugar de copiar y pegar código en cada acción de código.++Una función lógica se define una sola vez en una app (usando el `defineLogicFunction` del SDK) y se expone al generador de flujos de trabajo agregando `workflowActionTriggerSettings`. Una vez que tu app está instalada, esa función aparece como su propia acción en el generador de flujos de trabajo, junto con las acciones integradas. Al seleccionarla se muestran los campos de entrada que declaraste (con selectores de variables, como en las demás acciones) y se ejecuta tu código compartido; no se requiere JavaScript en línea.++| | Acción de código | Función lógica reutilizable |+| ------------------------ | -------------------------------------------------------- | -------------------------------------------------------------- |+| **Dónde vive el código** | Editor en línea, vinculado a un paso de flujo de trabajo | Definida en una app, versionada en el control de código fuente |+| **Reutilización** | Copiada y pegada por paso | Agregada como una acción en cualquier flujo de trabajo |+| **Entradas** | Variables conectadas en el editor | Campos mostrados a partir de tu esquema de entrada declarado |+| **Ideal para** | Lógica rápida y específica de un flujo de trabajo | Lógica compartida usada en varios flujos de trabajo |++Ambas se ejecutan en el mismo entorno de ejecución de funciones lógicas, por lo que una acción de código que hayas prototipado en línea puede luego promocionarse a una función lógica reutilizable con cambios mínimos.++<Tip>+Para la referencia orientada a desarrolladores sobre cómo definir funciones lógicas y exponerlas en el generador de flujos de trabajo, consulta [Logic Functions](/l/es/developers/extend/apps/logic/logic-functions), en particular la sección **Exposing a function as an AI tool or workflow action** y `workflowActionTriggerSettings`.+</Tip>+### Solicitud HTTPEnvía una solicitud a un API externo como parte de su flujo de trabajo.diff --git a/packages/twenty-docs/l/es/user-guide/workflows/how-tos/advanced-configurations/handle-arrays-in-code-actions.mdx b/packages/twenty-docs/l/es/user-guide/workflows/how-tos/advanced-configurations/handle-arrays-in-code-actions.mdxindex f2c2ce1dc69..145b57df42a 100644--- a/packages/twenty-docs/l/es/user-guide/workflows/how-tos/advanced-configurations/handle-arrays-in-code-actions.mdx+++ b/packages/twenty-docs/l/es/user-guide/workflows/how-tos/advanced-configurations/handle-arrays-in-code-actions.mdx@@ -73,9 +73,9 @@ export const main = async (params: {El nodo Code devuelve un objeto estructurado en lugar de un array. En los pasos posteriores, ahora puedes seleccionar campos individuales como `answer.firstname` y `answer.name` desde el selector de variables.-<Note>-Estamos trabajando activamente para facilitar el manejo de arrays en futuras actualizaciones.-</Note>+<Tip>+**¿Quieres iterar sobre el array en lugar de extraer campos?** Cuando un paso de Code o Logic Function devuelve un array de nivel superior, puedes pasarlo directamente a un [Iterator](/l/es/user-guide/workflows/capabilities/use-iterator): selecciona la opción **Whole list** del paso como la entrada del Iterator y luego haz referencia a cada elemento con `{{iterator.currentItem}}` dentro del bucle. En ese caso, no necesitas reestructurar el array en un objeto.+</Tip><Tip>Haz clic en el icono cuadrado en la parte superior derecha del editor de código para mostrarlo en pantalla completa — es útil, ya que el ancho predeterminado del editor es limitado.diff --git a/packages/twenty-docs/l/fr/developers/extend/apps/logic/logic-functions.mdx b/packages/twenty-docs/l/fr/developers/extend/apps/logic/logic-functions.mdxindex e886c294926..24ca9ce01b9 100644--- a/packages/twenty-docs/l/fr/developers/extend/apps/logic/logic-functions.mdx+++ b/packages/twenty-docs/l/fr/developers/extend/apps/logic/logic-functions.mdx@@ -412,6 +412,10 @@ Les fonctions logiques peuvent être exposées sur deux surfaces, chacune avec sUne fonction peut opter pour l'un, l'autre ou les deux. Elles côtoient `cronTriggerSettings`, `databaseEventTriggerSettings` et `httpRouteTriggerSettings` — même modèle, même structure.+<Note>+**Lien avec l’action Code du workflow.** L’action **Code** intégrée dans le générateur de workflows est elle-même une fonction logique — Twenty en crée une pour chaque étape Code et affiche son éditeur en ligne. `workflowActionTriggerSettings` est la manière de transformer ce code ponctuel en ligne en une action **réutilisable** : définissez la fonction une fois dans votre application et elle devient sélectionnable dans n’importe quel workflow, au lieu d’être copiée-collée dans chaque étape Code. Voir l’[action Code](/l/fr/user-guide/workflows/capabilities/workflow-actions#code) dans le guide utilisateur pour la vue côté utilisateur final.+</Note>+```ts src/logic-functions/enrich-company.logic-function.tsimport { defineLogicFunction } from 'twenty-sdk/define';import { CoreApiClient } from 'twenty-client-sdk/core';@@ -497,6 +501,77 @@ export default defineLogicFunction({});```+##### Un exemple complet d’action de workflow++`workflowActionTriggerSettings` accepte quatre champs :++| Champ | Objectif |+| -------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |+| `label` | Nom affiché pour l’action dans le sélecteur d’étapes du générateur de workflows. Utilise par défaut le `name` de la fonction. |+| `icon` | Icône affichée à côté de l’action (un nom `tabler-icons`, par exemple `IconBuilding`). |+| `inputSchema` | Le riche `InputSchema` de Twenty — ce que le générateur affiche sous forme de champs configurables (avec des sélecteurs de variables). Optionnel ; déduit du gestionnaire lorsqu’il est omis. |+| `outputSchema` | Déclare la structure renvoyée par le gestionnaire, afin que **les étapes suivantes puissent établir une correspondance avec ses champs de sortie**. Optionnel ; sans cela, la sortie est exposée comme une valeur opaque unique. |++Assembler le tout — une fonction exposée comme action de workflow, avec une sortie déclarée pour que les étapes ultérieures puissent référencer `taskId` :++```ts src/logic-functions/enrich-company.logic-function.ts+import { defineLogicFunction } from 'twenty-sdk/define';+import { jsonSchemaToInputSchema, type InputJsonSchema } from 'twenty-sdk/logic-function';+import { CoreApiClient } from 'twenty-client-sdk/core';++const inputSchema: InputJsonSchema = {+ type: 'object',+ properties: {+ companyName: { type: 'string', label: 'Company name' },+ domain: { type: 'string', label: 'Domain' },+ },+ required: ['companyName'],+};++const handler = async (params: { companyName: string; domain?: string }) => {+ const client = new CoreApiClient();++ const result = await client.mutation({+ createTask: {+ __args: {+ data: {+ title: `Enrich data for ${params.companyName}`,+ body: `Domain: ${params.domain ?? 'unknown'}`,+ },+ },+ id: true,+ },+ });++ // The keys returned here should match the `outputSchema` properties below.+ return { taskId: result.createTask.id, enriched: true };+};++export default defineLogicFunction({+ universalIdentifier: 'f47ac10b-58cc-4372-a567-0e02b2c3d479',+ name: 'enrich-company',+ description: 'Enrich a company record with external data',+ timeoutSeconds: 10,+ handler,+ workflowActionTriggerSettings: {+ label: 'Enrich Company',+ icon: 'IconBuilding',+ inputSchema: jsonSchemaToInputSchema(inputSchema),+ outputSchema: [+ {+ type: 'object',+ properties: {+ taskId: { type: 'string' },+ enriched: { type: 'boolean' },+ },+ },+ ],+ },+});+```++Une fois l’application installée, **Enrich Company** apparaît dans le sélecteur d’actions du générateur de workflows. Le générateur affiche `companyName` et `domain` sous forme de champs de saisie (chacun pouvant récupérer des valeurs à partir des étapes précédentes), et les étapes en aval peuvent référencer les sorties `taskId` et `enriched` de l’étape.+<Note>**Rédigez une bonne `description`.** Les agents IA s'appuient sur le champ `description` de la fonction pour décider quand utiliser l'outil. Soyez précis sur ce que fait l'outil et quand il doit être appelé.</Note>diff --git a/packages/twenty-docs/l/fr/user-guide/workflows/capabilities/use-iterator.mdx b/packages/twenty-docs/l/fr/user-guide/workflows/capabilities/use-iterator.mdxindex 8049381cd60..cf695a69634 100644--- a/packages/twenty-docs/l/fr/user-guide/workflows/capabilities/use-iterator.mdx+++ b/packages/twenty-docs/l/fr/user-guide/workflows/capabilities/use-iterator.mdx@@ -23,6 +23,12 @@ L'itérateur attend un **tableau** en entrée. Il va ensuite :3. Passe à l'élément suivant4. Répète jusqu'à ce que tous les éléments soient traités+### Sélection du tableau à parcourir++La plupart des sources de tableaux (Search Records, un champ de tableau de webhook, un déclencheur manuel Bulk) peuvent être sélectionnées directement dans le sélecteur de variables.++Lorsqu’une étape **Code** ou **Logic Function** renvoie un *tableau de premier niveau*, sa sortie apparaît dans le sélecteur de variables sous forme d’entrées indexées (`0`, `1`, `2`, …). Pour effectuer une boucle sur le tableau dans son ensemble, sélectionnez l’option **Whole list** pour cette étape — l’Iterator en déduit alors automatiquement la structure de chaque élément à partir de la liste.+## Configuration de base### Exemple : envoyer un e-mail à toutes les personnes dans les résultats de recherche@@ -77,6 +83,8 @@ Dans l'itérateur, utilisez `{{iterator.currentItem}}` pour accéder à l'enregi| `{{iterator.currentItem.company.name}}` | Nom de l'entreprise associée || `{{iterator.index}}` | Position actuelle dans le tableau (indexé à partir de 0) |+Dans le sélecteur de variables, vous pouvez soit explorer un champ spécifique de l’élément courant, soit choisir **Use the whole item** pour référencer l’intégralité de l’élément courant (`{{iterator.currentItem}}`). Sélectionner l’élément entier est pratique lorsque vous voulez transmettre un enregistrement complet directement à une étape en aval plutôt que de le reconstruire champ par champ.+## Modèles courants### Mettre à jour plusieurs enregistrementsdiff --git a/packages/twenty-docs/l/fr/user-guide/workflows/capabilities/workflow-actions.mdx b/packages/twenty-docs/l/fr/user-guide/workflows/capabilities/workflow-actions.mdxindex ae101b71475..843748889d2 100644--- a/packages/twenty-docs/l/fr/user-guide/workflows/capabilities/workflow-actions.mdx+++ b/packages/twenty-docs/l/fr/user-guide/workflows/capabilities/workflow-actions.mdx@@ -112,7 +112,7 @@ Crée un nouvel enregistrement ou met à jour un enregistrement existant en fonc**Configuration**:-* Sélectionnez le tableau d'enregistrements depuis une étape précédente (par ex., résultats de Rechercher des enregistrements, d'un déclencheur manuel avec exécution par lots, d'un nœud de code)+* Sélectionnez le tableau d'enregistrements depuis une étape précédente (par ex., résultats de Rechercher des enregistrements, d'un déclencheur manuel avec exécution par lots, d'un nœud de code). Lorsqu’une étape Code ou fonction logique renvoie un tableau de premier niveau, sélectionnez l’option **Whole list** pour itérer sur l’intégralité de la sortie.* Définissez les actions à effectuer sur chaque enregistrement dans la boucle.<Note>@@ -120,7 +120,7 @@ Crée un nouvel enregistrement ou met à jour un enregistrement existant en fonc- Lorsque vous utilisez des branches à l'intérieur d'un itérateur, assurez-vous que la dernière étape de chaque branche revient à l'itérateur pour fermer la boucle.</Note>-* Accéder aux champs `Current Item`: pour utiliser les champs de l'enregistrement en cours de traitement, cliquez sur l'étape **Iterator**, puis sélectionnez **Current item**. La liste des champs disponibles de cet enregistrement s'affichera et pourra être sélectionnée pour une utilisation dans les actions suivantes.+* Accéder aux champs `Current Item`: pour utiliser les champs de l'enregistrement en cours de traitement, cliquez sur l'étape **Iterator**, puis sélectionnez **Current item**. La liste des champs disponibles de cet enregistrement s'affichera et pourra être sélectionnée pour une utilisation dans les actions suivantes. Vous pouvez également sélectionner **Use the whole item** pour transmettre l’intégralité de l’élément en cours à une étape en aval.<VimeoEmbed videoId="1146577247" title="Démonstration vidéo" />@@ -245,6 +245,8 @@ Les champs ne peuvent pas être rendus obligatoires.Exécute du JavaScript personnalisé dans votre flux de travail.+En arrière-plan, chaque action de code est prise en charge par sa propre **fonction logique** — une fonction TypeScript côté serveur qui s’exécute sur la plateforme Twenty. Lorsque vous ajoutez une action de code, Twenty crée une fonction logique dédiée pour cette étape et affiche son éditeur en ligne, de sorte que le code que vous écrivez soit associé au workflow.+**Configuration**:* Accédez aux variables des étapes précédentes. Vous pouvez modifier dynamiquement les noms des variables.@@ -267,6 +269,25 @@ Si vous devez utiliser des clés d'API externes dans votre code, vous devez lesCliquez sur l'icône carrée en haut à droite de l'éditeur de code pour l'afficher en plein écran — utile car la largeur par défaut de l'éditeur est limitée.</Tip>+#### Réutiliser une fonction logique dans plusieurs workflows++L’action de code en ligne est idéale pour de la logique ponctuelle, mais le code qu’elle contient est propre à cette seule étape. Lorsque vous voulez partager la même logique entre plusieurs workflows — ou la maintenir comme code source versionné dans une application — définissez une **fonction logique réutilisable** au lieu de copier-coller du code dans chaque action de code.++Une fonction logique est définie une seule fois dans une application (à l’aide de `defineLogicFunction` du SDK) et exposée au concepteur de workflows en ajoutant `workflowActionTriggerSettings`. Une fois votre application installée, cette fonction apparaît comme une action à part entière dans le concepteur de workflows, à côté des actions intégrées. La sélectionner affiche les champs d’entrée que vous avez déclarés (avec des sélecteurs de variables, comme pour les autres actions) et exécute votre code mutualisé — aucun JavaScript en ligne n’est requis.++| | Action de code | Fonction logique réutilisable |+| ------------------------- | --------------------------------------------- | ------------------------------------------------------------------------------- |+| **Où le code est stocké** | Éditeur en ligne, lié à une étape de workflow | Définie dans une application, versionnée dans un système de contrôle de version |+| **Réutilisation** | Copié-collé par étape | Ajoutée comme action dans n’importe quel workflow |+| **Entrées** | Variables connectées dans l’éditeur | Champs générés à partir de votre schéma d’entrée déclaré |+| **Idéal pour** | Logique rapide, spécifique à un workflow | Logique partagée utilisée dans plusieurs workflows |++Les deux s’exécutent sur le même environnement d’exécution des fonctions logiques, de sorte qu’une action de code que vous avez prototypée en ligne peut ensuite être promue en fonction logique réutilisable avec des modifications minimales.++<Tip>+Pour la documentation destinée aux développeurs sur la définition des fonctions logiques et leur exposition dans le concepteur de workflows, consultez [Logic Functions](/l/fr/developers/extend/apps/logic/logic-functions) — en particulier la section **Exposing a function as an AI tool or workflow action** et `workflowActionTriggerSettings`.+</Tip>+### Requête HTTPEnvoie une requête à une API externe dans le cadre de votre flux de travail.diff --git a/packages/twenty-docs/l/fr/user-guide/workflows/how-tos/advanced-configurations/handle-arrays-in-code-actions.mdx b/packages/twenty-docs/l/fr/user-guide/workflows/how-tos/advanced-configurations/handle-arrays-in-code-actions.mdxindex 58c7758765d..87b8200611b 100644--- a/packages/twenty-docs/l/fr/user-guide/workflows/how-tos/advanced-configurations/handle-arrays-in-code-actions.mdx+++ b/packages/twenty-docs/l/fr/user-guide/workflows/how-tos/advanced-configurations/handle-arrays-in-code-actions.mdx@@ -73,9 +73,9 @@ export const main = async (params: {Le nœud Code renvoie un objet structuré au lieu d'un tableau. Dans les étapes suivantes, vous pouvez maintenant sélectionner des champs individuels comme `answer.firstname` et `answer.name` à partir du sélecteur de variables.-<Note>-Nous travaillons activement à faciliter la gestion des tableaux dans de futures mises à jour.-</Note>+<Tip>+**Vous voulez parcourir le tableau au lieu d'extraire des champs ?** Lorsqu'une étape de fonction Code ou Logic renvoie un tableau de premier niveau, vous pouvez l'envoyer directement dans un [Iterator](/l/fr/user-guide/workflows/capabilities/use-iterator) : sélectionnez l'option **Whole list** de l'étape comme entrée de l'Iterator, puis référencez chaque élément avec `{{iterator.currentItem}}` à l'intérieur de la boucle. Dans ce cas, vous n'avez pas besoin de restructurer le tableau en un objet.+</Tip><Tip>Cliquez sur l'icône carrée en haut à droite de l'éditeur de code pour l'afficher en plein écran — utile car la largeur par défaut de l'éditeur est limitée.diff --git a/packages/twenty-docs/l/it/developers/extend/apps/logic/logic-functions.mdx b/packages/twenty-docs/l/it/developers/extend/apps/logic/logic-functions.mdxindex bca00cba381..2a3978d992e 100644--- a/packages/twenty-docs/l/it/developers/extend/apps/logic/logic-functions.mdx+++ b/packages/twenty-docs/l/it/developers/extend/apps/logic/logic-functions.mdx@@ -411,6 +411,10 @@ Le funzioni logiche possono essere esposte su due superfici, ciascuna con il proUna funzione può optare per uno, l'altro o entrambi. Si affiancano a `cronTriggerSettings`, `databaseEventTriggerSettings` e `httpRouteTriggerSettings` — stesso schema, stessa struttura.+<Note>+**Relazione con l’azione Code del workflow.** L’azione **Code** incorporata nel generatore di workflow è essa stessa una funzione logica — Twenty ne crea una per ogni passaggio Code e ne espone l’editor inline. `workflowActionTriggerSettings` è il modo in cui trasformi quel codice inline una tantum in un’azione **riutilizzabile**: definisci la funzione una volta nella tua app e diventa selezionabile in qualsiasi workflow, invece di essere copiata e incollata in ogni passaggio Code. Consulta l’[azione Code](/l/it/user-guide/workflows/capabilities/workflow-actions#code) nella guida utente per la vista dell’utente finale.+</Note>+```ts src/logic-functions/enrich-company.logic-function.tsimport { defineLogicFunction } from 'twenty-sdk/define';import { CoreApiClient } from 'twenty-client-sdk/core';@@ -496,6 +500,77 @@ export default defineLogicFunction({});```+##### Un esempio completo di azione di workflow++`workflowActionTriggerSettings` accetta quattro campi:++| Campo | Scopo |+| -------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |+| `label` | Nome mostrato per l’azione nel selettore di passaggi del generatore di workflow. Il valore predefinito è il `name` della funzione. |+| `icon` | Icona mostrata accanto all’azione (un nome `tabler-icons`, ad esempio `IconBuilding`). |+| `inputSchema` | Il ricco `InputSchema` di Twenty: ciò che il generatore visualizza come campi configurabili (con selettori di variabili). Opzionale; quando omesso viene ricavato dall’handler. |+| `outputSchema` | Dichiara la struttura restituita dall’handler, così **i passaggi successivi possono mappare ai suoi campi di output**. Opzionale; senza di esso, l’output è esposto come singolo valore opaco. |++Mettendo tutto insieme: una funzione esposta come azione di workflow, con un output dichiarato così che i passaggi successivi possano fare riferimento a `taskId`:++```ts src/logic-functions/enrich-company.logic-function.ts+import { defineLogicFunction } from 'twenty-sdk/define';+import { jsonSchemaToInputSchema, type InputJsonSchema } from 'twenty-sdk/logic-function';+import { CoreApiClient } from 'twenty-client-sdk/core';++const inputSchema: InputJsonSchema = {+ type: 'object',+ properties: {+ companyName: { type: 'string', label: 'Company name' },+ domain: { type: 'string', label: 'Domain' },+ },+ required: ['companyName'],+};++const handler = async (params: { companyName: string; domain?: string }) => {+ const client = new CoreApiClient();++ const result = await client.mutation({+ createTask: {+ __args: {+ data: {+ title: `Enrich data for ${params.companyName}`,+ body: `Domain: ${params.domain ?? 'unknown'}`,+ },+ },+ id: true,+ },+ });++ // The keys returned here should match the `outputSchema` properties below.+ return { taskId: result.createTask.id, enriched: true };+};++export default defineLogicFunction({+ universalIdentifier: 'f47ac10b-58cc-4372-a567-0e02b2c3d479',+ name: 'enrich-company',+ description: 'Enrich a company record with external data',+ timeoutSeconds: 10,+ handler,+ workflowActionTriggerSettings: {+ label: 'Enrich Company',+ icon: 'IconBuilding',+ inputSchema: jsonSchemaToInputSchema(inputSchema),+ outputSchema: [+ {+ type: 'object',+ properties: {+ taskId: { type: 'string' },+ enriched: { type: 'boolean' },+ },+ },+ ],+ },+});+```++Una volta che l’app è installata, **Enrich Company** appare nel selettore di azioni del generatore di workflow. Il generatore visualizza `companyName` e `domain` come campi di input (ognuno in grado di prelevare valori dai passaggi precedenti), e i passaggi a valle possono fare riferimento ai risultati `taskId` ed `enriched` del passaggio.+<Note>**Scrivi una buona `description`.** Gli agenti IA fanno affidamento sul campo `description` della funzione per decidere quando usare lo strumento. Sii specifico su cosa fa lo strumento e quando dovrebbe essere invocato.</Note>diff --git a/packages/twenty-docs/l/it/user-guide/workflows/capabilities/use-iterator.mdx b/packages/twenty-docs/l/it/user-guide/workflows/capabilities/use-iterator.mdxindex fe28a70065d..29567b80d7e 100644--- a/packages/twenty-docs/l/it/user-guide/workflows/capabilities/use-iterator.mdx+++ b/packages/twenty-docs/l/it/user-guide/workflows/capabilities/use-iterator.mdx@@ -23,6 +23,12 @@ Iterator si aspetta un **array** come input. Quindi:3. Passa all'elemento successivo4. Ripete finché tutti gli elementi non sono stati elaborati+### Selezionare l'array su cui iterare++La maggior parte delle origini di array (Search Records, un campo array di un webhook, un trigger manuale Bulk) può essere selezionata direttamente nel selettore di variabili.++Quando uno step **Code** o **Logic Function** restituisce un *array di primo livello*, il relativo output viene visualizzato nel selettore di variabili come voci indicizzate (`0`, `1`, `2`, …). Per iterare sull'intero array, seleziona l'opzione **Whole list** per quello step — l'Iterator deduce quindi automaticamente la struttura di ciascun elemento dall'elenco.+## Configurazione di base### Esempio: inviare un'email a tutti nei risultati della ricerca@@ -77,6 +83,8 @@ All'interno di Iterator, usa `{{iterator.currentItem}}` per accedere al record c| `{{iterator.currentItem.company.name}}` | Nome dell'azienda correlata || `{{iterator.index}}` | Posizione corrente nell'array (indice a partire da 0) |+Nel selettore di variabili, puoi esplorare un campo specifico dell'elemento corrente oppure scegliere **Use the whole item** per fare riferimento all'intero elemento corrente (`{{iterator.currentItem}}`). Selezionare l'intero elemento è utile quando vuoi passare un record completo direttamente a uno step a valle invece di ricostruirlo campo per campo.+## Modelli comuni### Aggiornare più recorddiff --git a/packages/twenty-docs/l/it/user-guide/workflows/capabilities/workflow-actions.mdx b/packages/twenty-docs/l/it/user-guide/workflows/capabilities/workflow-actions.mdxindex 618181369b6..f20eda855ee 100644--- a/packages/twenty-docs/l/it/user-guide/workflows/capabilities/workflow-actions.mdx+++ b/packages/twenty-docs/l/it/user-guide/workflows/capabilities/workflow-actions.mdx@@ -112,7 +112,7 @@ Crea un nuovo record o aggiorna uno esistente in base ai criteri di corrisponden**Configurazione**:-* Seleziona l'array di record da un passaggio precedente (ad es., risultati da Search Records, da un trigger Manual con disponibilità Bulk, da un nodo di codice)+* Seleziona l'array di record da un passaggio precedente (ad es., risultati da Search Records, da un trigger Manual con disponibilità Bulk, da un nodo di codice). Quando un passaggio di tipo Code o Logic Function restituisce un array di primo livello, seleziona l'opzione **Whole list** per eseguire il loop su tutto l'output.* Definisci le azioni da eseguire su ciascun record nel ciclo.<Note>@@ -120,7 +120,7 @@ Crea un nuovo record o aggiorna uno esistente in base ai criteri di corrisponden- Quando utilizzi diramazioni all'interno di un iteratore, assicurati che l'ultimo passaggio di ciascuna diramazione si ricolleghi all'iteratore per chiudere il ciclo.</Note>-* Accedi ai campi di `Current Item`: per utilizzare i campi del record attualmente in elaborazione, fai clic sul passaggio **Iterator**, quindi seleziona **Current item**. Verrà visualizzato l'elenco dei campi disponibili di quel record e potrai selezionarli per l'uso nelle azioni successive.+* Accedi ai campi di `Current Item`: per utilizzare i campi del record attualmente in elaborazione, fai clic sul passaggio **Iterator**, quindi seleziona **Current item**. Verrà visualizzato l'elenco dei campi disponibili di quel record e potrai selezionarli per l'uso nelle azioni successive. Puoi anche selezionare **Use the whole item** per passare l'intero elemento corrente a un passaggio a valle.<VimeoEmbed videoId="1146577247" title="Dimostrazione video" />@@ -245,6 +245,8 @@ I campi non possono essere resi obbligatori.Esegue JavaScript personalizzato all'interno del tuo workflow.+In background, ogni azione Code è supportata dalla propria **logic function**, una funzione TypeScript lato server che viene eseguita sulla piattaforma Twenty. Quando aggiungi un'azione Code, Twenty crea una logic function dedicata per quel passaggio e ne espone l'editor inline, in modo che il codice che scrivi rimanga all'interno del flusso di lavoro.+**Configurazione**:* Accedi alle variabili dai passaggi precedenti. Puoi modificare dinamicamente i nomi delle variabili.@@ -267,6 +269,25 @@ Se devi utilizzare chiavi API esterne nel tuo codice, devi inserirle direttamentFai clic sull'icona quadrata in alto a destra dell'editor di codice per visualizzarlo a schermo intero — utile poiché la larghezza predefinita dell'editor è limitata.</Tip>+#### Riutilizzare una logic function tra i flussi di lavoro++L'azione Code inline è ideale per la logica "usa e getta", ma il codice che contiene appartiene a quel singolo passaggio. Quando vuoi condividere la stessa logica tra vari flussi di lavoro o mantenerla come sorgente versionata in un'app, definisci una **reusable logic function** al posto di copiare e incollare il codice in ogni azione Code.++Una logic function è definita una volta in un'app (usando l'SDK `defineLogicFunction`) ed esposta al generatore di flussi di lavoro aggiungendo `workflowActionTriggerSettings`. Una volta installata l'app, quella funzione compare come azione autonoma nel generatore di flussi di lavoro, insieme alle azioni integrate. Selezionandola, vengono mostrati i campi di input che hai dichiarato (con i selettori di variabili, proprio come per le altre azioni) e viene eseguito il tuo codice condiviso, senza bisogno di JavaScript inline.++| | Code action | Reusable logic function |+| -------------------------- | ----------------------------------------------------------------- | -------------------------------------------------------------------------------- |+| **Dove risiede il codice** | Editor inline, legato a un singolo passaggio del flusso di lavoro | Definita in un'app, sottoposta a versionamento nel controllo del codice sorgente |+| **Riutilizzo** | Copiata e incollata per ogni passaggio | Aggiunta come azione in qualsiasi flusso di lavoro |+| **Input** | Variabili collegate nell'editor | Campi generati dallo schema di input dichiarato |+| **Ideale per** | Logica rapida e specifica del flusso di lavoro | Logica condivisa usata in più flussi di lavoro |++Entrambe vengono eseguite sullo stesso runtime di logic function, quindi un'azione Code che hai prototipato inline può in seguito essere trasformata in una reusable logic function con modifiche minime.++<Tip>+Per le informazioni di riferimento destinate agli sviluppatori sulla definizione delle logic function e sulla loro esposizione al generatore di workflow, vedi [Logic Functions](/l/it/developers/extend/apps/logic/logic-functions), in particolare la sezione **Exposing a function as an AI tool or workflow action** e `workflowActionTriggerSettings`.+</Tip>+### Richiesta HTTPInvia una richiesta a un API esterno come parte del tuo workflow.diff --git a/packages/twenty-docs/l/it/user-guide/workflows/how-tos/advanced-configurations/handle-arrays-in-code-actions.mdx b/packages/twenty-docs/l/it/user-guide/workflows/how-tos/advanced-configurations/handle-arrays-in-code-actions.mdxindex 2192a9ee3ef..4f66e042112 100644--- a/packages/twenty-docs/l/it/user-guide/workflows/how-tos/advanced-configurations/handle-arrays-in-code-actions.mdx+++ b/packages/twenty-docs/l/it/user-guide/workflows/how-tos/advanced-configurations/handle-arrays-in-code-actions.mdx@@ -73,9 +73,9 @@ export const main = async (params: {Il nodo Code restituisce un oggetto strutturato invece di un array. Nei passaggi successivi, ora puoi selezionare campi individuali come `answer.firstname` e `answer.name` dal selettore delle variabili.-<Note>-Stiamo lavorando attivamente per rendere la gestione degli array più semplice nei prossimi aggiornamenti.-</Note>+<Tip>+**Vuoi iterare sull'array invece di estrarre i campi?** Quando uno step di Code o Logic Function restituisce un array di primo livello, puoi passarlo direttamente a un [Iterator](/l/it/user-guide/workflows/capabilities/use-iterator): seleziona l'opzione **Whole list** dello step come input dell'Iterator, quindi fai riferimento a ciascun elemento con `{{iterator.currentItem}}` all'interno del ciclo. In quel caso non è necessario ristrutturare l'array in un oggetto.+</Tip><Tip>Fai clic sull'icona quadrata in alto a destra dell'editor di codice per visualizzarlo a tutto schermo — utile poiché la larghezza predefinita dell'editor è limitata.diff --git a/packages/twenty-docs/l/ja/developers/extend/apps/logic/logic-functions.mdx b/packages/twenty-docs/l/ja/developers/extend/apps/logic/logic-functions.mdxindex bdee689b4ce..d6ffe986c6e 100644--- a/packages/twenty-docs/l/ja/developers/extend/apps/logic/logic-functions.mdx+++ b/packages/twenty-docs/l/ja/developers/extend/apps/logic/logic-functions.mdx@@ -412,6 +412,10 @@ const handler = async (event: PersonDestroyedEvent) => {関数は一方、もう一方、またはその両方を選択できます。 これらは `cronTriggerSettings`、`databaseEventTriggerSettings`、`httpRouteTriggerSettings` と並列に存在します — 同じパターン、同じ形です。+<Note>+**ワークフローの Code アクションとの関係。** ワークフロービルダーに組み込まれている **Code** アクション自体もロジック関数です。Twenty は Code ステップごとに 1 つ作成し、そのエディタをインラインで表示します。 `workflowActionTriggerSettings` を使うことで、その使い捨てのインラインコードを**再利用可能な**アクションに変換できます。アプリ内でその関数を 1 度定義すれば、各 Code ステップにコードをコピーペーストする代わりに、任意のワークフローで選択できるようになります。 エンドユーザー側の表示については、ユーザーガイドの [Code action](/l/ja/user-guide/workflows/capabilities/workflow-actions#code) を参照してください。+</Note>+```ts src/logic-functions/enrich-company.logic-function.tsimport { defineLogicFunction } from 'twenty-sdk/define';import { CoreApiClient } from 'twenty-client-sdk/core';@@ -497,6 +501,77 @@ export default defineLogicFunction({});```+##### ワークフローアクションの完全な例++`workflowActionTriggerSettings` は 4 つのフィールドを受け取ります:++| フィールド | 目的 |+| -------------- | -------------------------------------------------------------------------------------------------- |+| `label` | ワークフロービルダーのステップピッカーに表示されるアクション名。 指定しない場合は、関数の `name` がデフォルトになります。 |+| `icon` | アクションの横に表示されるアイコン(`tabler-icons` の名前。例: `IconBuilding`)。 |+| `inputSchema` | Twenty のリッチな `InputSchema` — ビルダーが設定可能なフィールド(変数ピッカー付き)としてレンダリングするものです。 省略可能。省略された場合はハンドラーから推論されます。 |+| `outputSchema` | ハンドラーが返すデータの形を宣言し、**後続のステップがその出力フィールドへマッピングできるようにします**。 省略可能。指定しない場合、出力は単一の不透明な値として公開されます。 |++これらを組み合わせると、ワークフローアクションとして公開される関数になり、`taskId` を後続ステップから参照できるように出力を宣言できます。++```ts src/logic-functions/enrich-company.logic-function.ts+import { defineLogicFunction } from 'twenty-sdk/define';+import { jsonSchemaToInputSchema, type InputJsonSchema } from 'twenty-sdk/logic-function';+import { CoreApiClient } from 'twenty-client-sdk/core';++const inputSchema: InputJsonSchema = {+ type: 'object',+ properties: {+ companyName: { type: 'string', label: 'Company name' },+ domain: { type: 'string', label: 'Domain' },+ },+ required: ['companyName'],+};++const handler = async (params: { companyName: string; domain?: string }) => {+ const client = new CoreApiClient();++ const result = await client.mutation({+ createTask: {+ __args: {+ data: {+ title: `Enrich data for ${params.companyName}`,+ body: `Domain: ${params.domain ?? 'unknown'}`,+ },+ },+ id: true,+ },+ });++ // The keys returned here should match the `outputSchema` properties below.+ return { taskId: result.createTask.id, enriched: true };+};++export default defineLogicFunction({+ universalIdentifier: 'f47ac10b-58cc-4372-a567-0e02b2c3d479',+ name: 'enrich-company',+ description: 'Enrich a company record with external data',+ timeoutSeconds: 10,+ handler,+ workflowActionTriggerSettings: {+ label: 'Enrich Company',+ icon: 'IconBuilding',+ inputSchema: jsonSchemaToInputSchema(inputSchema),+ outputSchema: [+ {+ type: 'object',+ properties: {+ taskId: { type: 'string' },+ enriched: { type: 'boolean' },+ },+ },+ ],+ },+});+```++アプリがインストールされると、ワークフロービルダーのアクションピッカーに **Enrich Company** が表示されます。 ビルダーは `companyName` と `domain` を入力フィールドとしてレンダリングします(それぞれが前のステップから値を取得可能)、さらに下流のステップでは、そのステップの `taskId` と `enriched` の出力を参照できます。+<Note>**良い `description` を記述してください。** AI エージェントは、ツールをいつ使用するかを判断するために関数の `description` フィールドに依存します。 ツールが何を行い、いつ呼び出すべきかを具体的に記述してください。</Note>diff --git a/packages/twenty-docs/l/ja/user-guide/workflows/capabilities/use-iterator.mdx b/packages/twenty-docs/l/ja/user-guide/workflows/capabilities/use-iterator.mdxindex b9ad1563d4f..687bffc21be 100644--- a/packages/twenty-docs/l/ja/user-guide/workflows/capabilities/use-iterator.mdx+++ b/packages/twenty-docs/l/ja/user-guide/workflows/capabilities/use-iterator.mdx@@ -23,6 +23,12 @@ Iterator は入力として**配列**を想定しています。 その後、次3. 次のアイテムに進む4. すべてのアイテムが処理されるまで繰り返す+### ループ処理する配列の選択++ほとんどの配列ソース(Search Records、webhook の配列フィールド、Bulk manual trigger)は、変数ピッカーで直接選択できます。++**Code** ステップや **Logic Function** ステップが*トップレベル配列*を返す場合、その出力は変数ピッカー内でインデックス付きエントリ(`0`、`1`、`2`、…)として表示されます。 配列全体をループ処理するには、そのステップの **Whole list** オプションを選択します。Iterator は、そのリストから各アイテムの構造を自動的に推論します。+## 基本的なセットアップ### 例: 検索結果の全員にメールを送信@@ -77,6 +83,8 @@ Iterator 内では、現在のレコードにアクセスするために `{{iter| `{{iterator.currentItem.company.name}}` | 関連する会社名 || `{{iterator.index}}` | 配列内の現在の位置(0 始まり) |+変数ピッカーでは、現在のアイテムの特定のフィールドまでドリルダウンして選択するか、**Use the whole item** を選択して、現在のアイテム全体(`{{iterator.currentItem}}`)を参照できます。 アイテム全体を選択すると、フィールドを 1 つずつ再構築するのではなく、完全なレコードをそのまま後続ステップに渡したい場合に便利です。+## よくあるパターン### 複数レコードを更新diff --git a/packages/twenty-docs/l/ja/user-guide/workflows/capabilities/workflow-actions.mdx b/packages/twenty-docs/l/ja/user-guide/workflows/capabilities/workflow-actions.mdxindex d66d8bccc2b..4b4fa8b2353 100644--- a/packages/twenty-docs/l/ja/user-guide/workflows/capabilities/workflow-actions.mdx+++ b/packages/twenty-docs/l/ja/user-guide/workflows/capabilities/workflow-actions.mdx@@ -112,7 +112,7 @@ import { VimeoEmbed } from '/snippets/vimeo-embed.mdx';**設定**:-* 前の手順からレコードの配列を選択します(例:Search Records の結果、Bulk に対応した手動トリガー、コードノード)+* 前の手順からレコードの配列を選択します(例:Search Records の結果、Bulk に対応した手動トリガー、コードノード)。 Code または Logic Function ステップがトップレベルの配列を返す場合は、その出力全体をループ処理するために **Whole list** オプションを選択します。* ループ内の各レコードで実行するアクションを定義.<Note>@@ -120,7 +120,7 @@ import { VimeoEmbed } from '/snippets/vimeo-embed.mdx';- イテレーター内で分岐を使用する場合、各分岐の最後のステップがループを閉じるようにイテレーターへ戻る接続になっていることを確認してください。</Note>-* `Current Item` フィールドにアクセス:現在処理中のレコードのフィールドを使用するには、**Iterator** ステップをクリックし、**Current item** を選択します。 そのレコードで使用可能なフィールドの一覧が表示され、後続のアクションで使用するために選択できます。+* `Current Item` フィールドにアクセス:現在処理中のレコードのフィールドを使用するには、**Iterator** ステップをクリックし、**Current item** を選択します。 そのレコードで使用可能なフィールドの一覧が表示され、後続のアクションで使用するために選択できます。 現在のアイテム全体を後続ステップに渡すには、**Use the whole item** を選択することもできます。<VimeoEmbed videoId="1146577247" title="デモ動画" />@@ -245,6 +245,8 @@ import { VimeoEmbed } from '/snippets/vimeo-embed.mdx';ワークフロー内でカスタムJavaScriptを実行します。+内部的には、それぞれの Code アクションは独自の **ロジック関数** によって支えられています。これは Twenty プラットフォーム上で実行されるサーバーサイドの TypeScript 関数です。 Code アクションを追加すると、Twenty はそのステップ専用のロジック関数を作成し、そのエディタをインラインで表示します。そのため、記述したコードはワークフローと一体となって存在します。+**設定**:* 前の手順からの変数にアクセス. 変数名を動的に編集できます。@@ -267,6 +269,25 @@ import { VimeoEmbed } from '/snippets/vimeo-embed.mdx';コードエディタ右上の四角いアイコンをクリックすると全画面表示になります — デフォルトのエディタ幅には制限があるため便利です。</Tip>+#### ワークフロー間でロジック関数を再利用する++インラインの Code アクションは単発のロジックには最適ですが、その中に保持されるコードはその 1 つのステップ専用のものです。 複数のワークフロー間で同じロジックを共有したい場合や、アプリ内でバージョン管理されたソースとして維持したい場合は、各 Code アクションにコードをコピーペーストするのではなく、**再利用可能なロジック関数** を定義します。++ロジック関数は、アプリ内で一度だけ(SDK の `defineLogicFunction` を使用して)定義され、`workflowActionTriggerSettings` を追加することでワークフロービルダーに公開されます。 アプリがインストールされると、その関数は組み込みアクションと並んで、ワークフロービルダー内で 1 つのアクションとして表示されます。 それを選択すると、宣言した入力スキーマから生成された入力フィールド(他のアクションと同様に変数ピッカー付き)が表示され、共有コードが実行されます。インラインの JavaScript は不要です。++| | コードアクション | 再利用可能なロジック関数 |+| ---------- | --------------------------------- | -------------------------- |+| **コードの所在** | インラインエディタで記述され、1 つのワークフローステップに紐づく | アプリ内で定義され、ソース管理でバージョン管理される |+| **再利用性** | ステップごとにコピー&ペースト | 任意のワークフローでアクションとして追加可能 |+| **入力** | エディタ内で接続された変数 | 宣言した入力スキーマからレンダリングされるフィールド |+| **最適な用途** | 手早く記述できる、ワークフロー固有のロジック | 複数のワークフローで使用される共有ロジック |++両者は同じロジック関数ランタイム上で実行されるため、インラインで試作した Code アクションは、最小限の変更で再利用可能なロジック関数へ昇格させることができます。++<Tip>+ロジック関数を定義し、それらをワークフロービルダーに公開する方法に関する開発者向けリファレンスについては、[Logic Functions](/l/ja/developers/extend/apps/logic/logic-functions) を参照してください。特に **Exposing a function as an AI tool or workflow action** セクションと `workflowActionTriggerSettings` を確認してください。+</Tip>+### HTTPリクエストワークフローの一部として外部APIにリクエストを送信します。diff --git a/packages/twenty-docs/l/ja/user-guide/workflows/how-tos/advanced-configurations/handle-arrays-in-code-actions.mdx b/packages/twenty-docs/l/ja/user-guide/workflows/how-tos/advanced-configurations/handle-arrays-in-code-actions.mdxindex cc547e2ca19..5e0aff2398f 100644--- a/packages/twenty-docs/l/ja/user-guide/workflows/how-tos/advanced-configurations/handle-arrays-in-code-actions.mdx+++ b/packages/twenty-docs/l/ja/user-guide/workflows/how-tos/advanced-configurations/handle-arrays-in-code-actions.mdx@@ -73,9 +73,9 @@ export const main = async (params: {この Code ノードは、配列ではなく構造化オブジェクトを返します。 以降のステップでは、変数ピッカーから `answer.firstname` や `answer.name` のような個別フィールドを選択できるようになります。-<Note>-将来のアップデートで配列の扱いをより簡単にできるよう、積極的に改善を進めています。-</Note>+<Tip>+**配列からフィールドを取り出す代わりに、配列自体をループ処理したいですか?** Code ステップまたは Logic Function ステップがトップレベルの配列を返す場合は、それをそのまま [Iterator](/l/ja/user-guide/workflows/capabilities/use-iterator) に渡せます。Iterator の入力としてそのステップの **Whole list** オプションを選択し、ループ内では `{{iterator.currentItem}}` を使って各要素を参照します。 その場合、配列をオブジェクトに再構成する必要はありません。+</Tip><Tip>コードエディタ右上の四角いアイコンをクリックすると全画面表示になります — デフォルトのエディタ幅には制限があるため便利です。diff --git a/packages/twenty-docs/l/ko/developers/extend/apps/logic/logic-functions.mdx b/packages/twenty-docs/l/ko/developers/extend/apps/logic/logic-functions.mdxindex 71c56f841a5..01e717e69d0 100644--- a/packages/twenty-docs/l/ko/developers/extend/apps/logic/logic-functions.mdx+++ b/packages/twenty-docs/l/ko/developers/extend/apps/logic/logic-functions.mdx@@ -411,6 +411,10 @@ const handler = async (event: PersonDestroyedEvent) => {함수는 둘 중 하나만 또는 둘 다 선택할 수 있습니다. 이들 설정은 `cronTriggerSettings`, `databaseEventTriggerSettings`, `httpRouteTriggerSettings`와 나란히 위치하며 — 패턴도 형태도 동일합니다.+<Note>+**워크플로 Code 액션과의 관계.** 워크플로 빌더에 내장된 **Code** 액션 자체가 하나의 로직 함수입니다. Twenty는 Code 단계마다 하나씩 생성하고, 해당 편집기를 인라인으로 노출합니다. `workflowActionTriggerSettings`는 그러한 일회성 인라인 코드를 **재사용 가능한** 액션으로 전환하는 방법입니다. 앱에서 함수를 한 번만 정의하면, 각 Code 단계에 코드를 복사·붙여넣기 하는 대신 모든 워크플로에서 선택할 수 있게 됩니다. 엔드유저 관점에 대해서는 사용자 가이드의 [Code 액션](/l/ko/user-guide/workflows/capabilities/workflow-actions#code)을 참고하세요.+</Note>+```ts src/logic-functions/enrich-company.logic-function.tsimport { defineLogicFunction } from 'twenty-sdk/define';import { CoreApiClient } from 'twenty-client-sdk/core';@@ -496,6 +500,77 @@ export default defineLogicFunction({});```+##### 완전한 워크플로 액션 예제++`workflowActionTriggerSettings`는 네 가지 필드를 받습니다:++| 필드 | 목적 |+| -------------- | --------------------------------------------------------------------------------------------------- |+| `label` | 워크플로 빌더의 단계 선택기에서 액션에 표시되는 이름입니다. 기본값은 함수의 `name`입니다. |+| `icon` | 액션 옆에 표시되는 아이콘입니다 (`tabler-icons` 이름, 예: `IconBuilding`). |+| `inputSchema` | 빌더에서 구성 가능한 필드(변수 선택기 포함)로 렌더링되는 Twenty의 강력한 `InputSchema`입니다. 선택 사항입니다. 생략하면 핸들러에서 자동으로 유추됩니다. |+| `outputSchema` | 핸들러가 반환하는 데이터 구조를 선언하여, **이후 단계가 해당 출력 필드에 매핑할 수 있도록 합니다**. 선택 사항입니다. 이것이 없으면 출력은 단일 불투명 값으로 노출됩니다. |++이 모든 것을 하나로 — 선언된 출력을 통해 이후 단계에서 `taskId`를 참조할 수 있는, 워크플로 액션으로 노출된 함수 예시는 다음과 같습니다:++```ts src/logic-functions/enrich-company.logic-function.ts+import { defineLogicFunction } from 'twenty-sdk/define';+import { jsonSchemaToInputSchema, type InputJsonSchema } from 'twenty-sdk/logic-function';+import { CoreApiClient } from 'twenty-client-sdk/core';++const inputSchema: InputJsonSchema = {+ type: 'object',+ properties: {+ companyName: { type: 'string', label: 'Company name' },+ domain: { type: 'string', label: 'Domain' },+ },+ required: ['companyName'],+};++const handler = async (params: { companyName: string; domain?: string }) => {+ const client = new CoreApiClient();++ const result = await client.mutation({+ createTask: {+ __args: {+ data: {+ title: `Enrich data for ${params.companyName}`,+ body: `Domain: ${params.domain ?? 'unknown'}`,+ },+ },+ id: true,+ },+ });++ // The keys returned here should match the `outputSchema` properties below.+ return { taskId: result.createTask.id, enriched: true };+};++export default defineLogicFunction({+ universalIdentifier: 'f47ac10b-58cc-4372-a567-0e02b2c3d479',+ name: 'enrich-company',+ description: 'Enrich a company record with external data',+ timeoutSeconds: 10,+ handler,+ workflowActionTriggerSettings: {+ label: 'Enrich Company',+ icon: 'IconBuilding',+ inputSchema: jsonSchemaToInputSchema(inputSchema),+ outputSchema: [+ {+ type: 'object',+ properties: {+ taskId: { type: 'string' },+ enriched: { type: 'boolean' },+ },+ },+ ],+ },+});+```++앱이 설치되면 **Enrich Company**가 워크플로 빌더의 액션 선택기에 나타납니다. 빌더는 `companyName`과 `domain`을 입력 필드로 렌더링하며(각각 이전 단계에서 값을 가져올 수 있음), 이후 단계에서는 해당 단계의 `taskId` 및 `enriched` 출력 값을 참조할 수 있습니다.+<Note>**좋은 `description`을 작성하세요.** AI 에이전트는 도구를 언제 사용할지 결정하기 위해 함수의 `description` 필드에 의존합니다. 도구가 무엇을 하는지와 언제 호출해야 하는지 구체적으로 작성하세요.</Note>diff --git a/packages/twenty-docs/l/ko/user-guide/workflows/capabilities/use-iterator.mdx b/packages/twenty-docs/l/ko/user-guide/workflows/capabilities/use-iterator.mdxindex 721fca95243..9eff4f3ad78 100644--- a/packages/twenty-docs/l/ko/user-guide/workflows/capabilities/use-iterator.mdx+++ b/packages/twenty-docs/l/ko/user-guide/workflows/capabilities/use-iterator.mdx@@ -23,6 +23,12 @@ Iterator는 입력으로 **배열**을 필요로 합니다. 그다음:3. 다음 항목으로 이동합니다4. 모든 항목이 처리될 때까지 반복합니다+### 반복할 배열 선택하기++대부분의 배열 소스(레코드 검색, 웹훅 배열 필드, 일괄 수동 트리거)는 변수 선택기에서 직접 선택할 수 있습니다.++**Code** 또는 **Logic Function** 단계가 *최상위 배열*을 반환하면, 그 출력은 변수 선택기에서 인덱스가 매겨진 항목들(`0`, `1`, `2`, …)로 표시됩니다. 배열 전체를 순회하려면 해당 단계에서 **Whole list** 옵션을 선택하세요. 그러면 Iterator가 목록에서 각 항목의 구조를 자동으로 추론합니다.+## 기본 설정### 예시: 검색 결과의 모든 사람에게 이메일 보내기@@ -77,6 +83,8 @@ Iterator 내부에서 현재 레코드에 접근하려면 `{{iterator.currentIte| `{{iterator.currentItem.company.name}}` | 연관된 회사 이름 || `{{iterator.index}}` | 배열에서의 현재 위치(0부터 시작) |+변수 선택기에서 현재 항목의 특정 필드로 들어가거나, **Use the whole item**을 선택해 현재 항목 전체(`{{iterator.currentItem}}`)를 참조할 수 있습니다. 전체 항목을 선택하면, 필드를 하나씩 다시 구성하는 대신 전체 레코드를 그대로 후속 단계로 전달하고자 할 때 유용합니다.+## 일반적인 패턴### 여러 레코드 업데이트diff --git a/packages/twenty-docs/l/ko/user-guide/workflows/capabilities/workflow-actions.mdx b/packages/twenty-docs/l/ko/user-guide/workflows/capabilities/workflow-actions.mdxindex ae5c3dc8312..3a1b9556cdb 100644--- a/packages/twenty-docs/l/ko/user-guide/workflows/capabilities/workflow-actions.mdx+++ b/packages/twenty-docs/l/ko/user-guide/workflows/capabilities/workflow-actions.mdx@@ -112,7 +112,7 @@ import { VimeoEmbed } from '/snippets/vimeo-embed.mdx';**구성**:-* 이전 단계의 레코드 배열을 선택합니다(예: Search Records 결과, 대량 사용이 가능한 수동 트리거, 코드 노드).+* 이전 단계의 레코드 배열을 선택합니다(예: Search Records 결과, 대량 사용이 가능한 수동 트리거, 코드 노드). Code 또는 Logic Function 단계가 최상위 배열을 반환하는 경우, **Whole list** 옵션을 선택하여 전체 출력에 대해 루프를 실행합니다.* 반복 내에서 각 레코드에 대해 수행할 액션 정의.<Note>@@ -120,7 +120,7 @@ import { VimeoEmbed } from '/snippets/vimeo-embed.mdx';- 이터레이터 내부에 분기를 사용할 때, 각 분기의 마지막 단계가 루프를 닫도록 이터레이터로 다시 연결되는지 확인하세요.</Note>-* `Current Item` 필드에 접근: 현재 처리 중인 레코드의 필드를 사용하려면 **Iterator** 단계에서 **Current item**을 선택하세요. 해당 레코드에서 사용 가능한 필드 목록이 표시되며, 이후 작업에서 사용하도록 선택할 수 있습니다.+* `Current Item` 필드에 접근: 현재 처리 중인 레코드의 필드를 사용하려면 **Iterator** 단계에서 **Current item**을 선택하세요. 해당 레코드에서 사용 가능한 필드 목록이 표시되며, 이후 작업에서 사용하도록 선택할 수 있습니다. **Use the whole item**을 선택하여 현재 항목 전체를 다운스트림 단계로 전달할 수도 있습니다.<VimeoEmbed videoId="1146577247" title="동영상 시연" />@@ -245,6 +245,8 @@ import { VimeoEmbed } from '/snippets/vimeo-embed.mdx';워크플로우 내에서 사용자 정의 JavaScript를 실행합니다.+백그라운드에서는 각 Code 액션이 자체 **logic function**으로 지원됩니다. 이는 Twenty 플랫폼에서 실행되는 서버 측 TypeScript 함수입니다. Code 액션을 추가하면 Twenty가 해당 단계에 대한 전용 logic function을 생성하고 편집기를 인라인으로 노출하므로, 작성한 코드는 워크플로와 함께 존재하게 됩니다.+**구성**:* 이전 단계의 변수에 접근. 변수 이름을 동적으로 편집할 수 있습니다.@@ -267,6 +269,25 @@ import { VimeoEmbed } from '/snippets/vimeo-embed.mdx';코드 편집기 오른쪽 상단의 사각형 아이콘을 클릭하여 전체 화면으로 표시하세요 — 기본 편집기 너비가 제한되어 있어 유용합니다.</Tip>+#### 워크플로 간에 logic function 재사용하기++인라인 Code 액션은 단발성 로직에는 유용하지만, 그 안의 코드는 해당 단일 단계에만 속합니다. 여러 워크플로 전반에서 동일한 로직을 공유하거나 앱에서 버전 관리되는 소스로 유지하려면, 각 Code 액션에 코드를 복사해 붙여넣는 대신 **재사용 가능한 logic function**을 정의하세요.++logic function은 앱에서 한 번(`defineLogicFunction`을 사용해) 정의되고, `workflowActionTriggerSettings`를 추가하여 워크플로 빌더에 노출됩니다. 앱이 설치되면, 해당 함수는 기본 제공 액션과 함께 워크플로 빌더에서 자체 액션으로 표시됩니다. 이를 선택하면 선언한 입력 스키마에서 렌더링된 입력 필드(다른 액션과 마찬가지로 변수 선택기 포함)가 표시되고, 인라인 JavaScript 없이 공유 코드를 실행합니다.++| | Code 액션 | 재사용 가능한 logic function |+| -------------- | ----------------------- | ------------------------ |+| **코드가 위치하는 곳** | 인라인 편집기, 단일 워크플로 단계에 연결 | 앱에서 정의되고, 소스 관리에서 버전 관리됨 |+| **재사용성** | 단계별로 복사해 붙여넣기 | 모든 워크플로에서 액션으로 추가 |+| **입력값** | 편집기에서 연결된 변수들 | 선언한 입력 스키마에서 렌더링된 필드 |+| **적합한 용도** | 빠른, 워크플로 전용 로직 | 여러 워크플로 전반에서 사용하는 공유 로직 |++둘 다 동일한 logic function 런타임에서 실행되므로, 인라인으로 프로토타이핑한 Code 액션은 최소한의 변경으로 재사용 가능한 logic function으로 승격할 수 있습니다.++<Tip>+logic function 정의 및 워크플로 빌더에 노출하는 방법에 대한 개발자용 레퍼런스는 [Logic Functions](/l/ko/developers/extend/apps/logic/logic-functions)를 참고하세요. 특히 **Exposing a function as an AI tool or workflow action** 섹션과 `workflowActionTriggerSettings`를 확인하세요.+</Tip>+### HTTP 요청워크플로우의 일부로 외부 API에 요청을 보냅니다.diff --git a/packages/twenty-docs/l/ko/user-guide/workflows/how-tos/advanced-configurations/handle-arrays-in-code-actions.mdx b/packages/twenty-docs/l/ko/user-guide/workflows/how-tos/advanced-configurations/handle-arrays-in-code-actions.mdxindex acac7272497..87d405a97ca 100644--- a/packages/twenty-docs/l/ko/user-guide/workflows/how-tos/advanced-configurations/handle-arrays-in-code-actions.mdx+++ b/packages/twenty-docs/l/ko/user-guide/workflows/how-tos/advanced-configurations/handle-arrays-in-code-actions.mdx@@ -73,9 +73,9 @@ export const main = async (params: {Code 노드는 배열 대신 구조화된 객체를 반환합니다. 이후 단계에서는 변수 선택기에서 `answer.firstname` 및 `answer.name`과 같은 개별 필드를 선택할 수 있습니다.-<Note>-향후 업데이트에서 배열 처리를 더 쉽게 만들기 위해 적극적으로 개선하고 있습니다.-</Note>+<Tip>+**배열에서 필드를 추출하는 대신 배열을 순회(loop)하고 싶으신가요?** Code 또는 Logic Function 단계가 최상위 배열을 반환하는 경우, 해당 결과를 바로 [Iterator](/l/ko/user-guide/workflows/capabilities/use-iterator)에 전달할 수 있습니다. 해당 단계의 **Whole list** 옵션을 Iterator의 입력으로 선택한 다음, 루프 안에서 각 요소를 `{{iterator.currentItem}}`으로 참조하면 됩니다. 그 경우에는 배열을 객체로 변환할 필요가 없습니다.+</Tip><Tip>코드 편집기 오른쪽 상단의 사각형 아이콘을 클릭하여 전체 화면으로 표시하세요 — 기본 편집기 너비가 제한되어 있어 유용합니다.diff --git a/packages/twenty-docs/l/pt/developers/extend/apps/logic/logic-functions.mdx b/packages/twenty-docs/l/pt/developers/extend/apps/logic/logic-functions.mdxindex 5d531c0fbf3..c8b0ab58358 100644--- a/packages/twenty-docs/l/pt/developers/extend/apps/logic/logic-functions.mdx+++ b/packages/twenty-docs/l/pt/developers/extend/apps/logic/logic-functions.mdx@@ -411,6 +411,10 @@ As funções de lógica podem ser expostas em duas superfícies, cada uma com seUma função pode optar por uma, pela outra ou por ambas. Ficam ao lado de `cronTriggerSettings`, `databaseEventTriggerSettings` e `httpRouteTriggerSettings` — mesmo padrão, mesmo formato.+<Note>+**Relação com a ação Code do fluxo de trabalho.** A ação **Code** incorporada no construtor de fluxos de trabalho é, em si, uma função lógica — a Twenty cria uma para cada etapa Code e exibe seu editor em linha. `workflowActionTriggerSettings` é como você transforma esse código em linha único em uma ação **reutilizável**: defina a função uma vez no seu app e ela se torna selecionável em qualquer fluxo de trabalho, em vez de ser copiada e colada em cada etapa Code. Veja a [ação Code](/l/pt/user-guide/workflows/capabilities/workflow-actions#code) no guia do usuário para a visão do usuário final.+</Note>+```ts src/logic-functions/enrich-company.logic-function.tsimport { defineLogicFunction } from 'twenty-sdk/define';import { CoreApiClient } from 'twenty-client-sdk/core';@@ -496,6 +500,77 @@ export default defineLogicFunction({});```+##### Um exemplo completo de ação de fluxo de trabalho++`workflowActionTriggerSettings` aceita quatro campos:++| Campo | Finalidade |+| -------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |+| `label` | Nome exibido para a ação no seletor de etapas do construtor de fluxos de trabalho. O padrão é o `name` da função. |+| `icon` | Ícone exibido ao lado da ação (um nome de `tabler-icons`, por exemplo `IconBuilding`). |+| `inputSchema` | O rico `InputSchema` da Twenty — o que o construtor renderiza como campos configuráveis (com seletores de variáveis). Opcional; inferido a partir do handler quando omitido. |+| `outputSchema` | Declara o formato que o handler retorna, para que **as etapas subsequentes possam mapear para seus campos de saída**. Opcional; sem isso, a saída é exposta como um único valor opaco. |++Juntando tudo — uma função exposta como uma ação de fluxo de trabalho, com uma saída declarada para que etapas posteriores possam referenciar `taskId`:++```ts src/logic-functions/enrich-company.logic-function.ts+import { defineLogicFunction } from 'twenty-sdk/define';+import { jsonSchemaToInputSchema, type InputJsonSchema } from 'twenty-sdk/logic-function';+import { CoreApiClient } from 'twenty-client-sdk/core';++const inputSchema: InputJsonSchema = {+ type: 'object',+ properties: {+ companyName: { type: 'string', label: 'Company name' },+ domain: { type: 'string', label: 'Domain' },+ },+ required: ['companyName'],+};++const handler = async (params: { companyName: string; domain?: string }) => {+ const client = new CoreApiClient();++ const result = await client.mutation({+ createTask: {+ __args: {+ data: {+ title: `Enrich data for ${params.companyName}`,+ body: `Domain: ${params.domain ?? 'unknown'}`,+ },+ },+ id: true,+ },+ });++ // The keys returned here should match the `outputSchema` properties below.+ return { taskId: result.createTask.id, enriched: true };+};++export default defineLogicFunction({+ universalIdentifier: 'f47ac10b-58cc-4372-a567-0e02b2c3d479',+ name: 'enrich-company',+ description: 'Enrich a company record with external data',+ timeoutSeconds: 10,+ handler,+ workflowActionTriggerSettings: {+ label: 'Enrich Company',+ icon: 'IconBuilding',+ inputSchema: jsonSchemaToInputSchema(inputSchema),+ outputSchema: [+ {+ type: 'object',+ properties: {+ taskId: { type: 'string' },+ enriched: { type: 'boolean' },+ },+ },+ ],+ },+});+```++Depois que o app é instalado, **Enrich Company** aparece no seletor de ações do construtor de fluxos de trabalho. O construtor renderiza `companyName` e `domain` como campos de entrada (cada um podendo extrair valores de etapas anteriores), e as etapas subsequentes podem referenciar as saídas `taskId` e `enriched` da etapa.+<Note>**Escreva uma boa `description`.** Os agentes de IA dependem do campo `description` da função para decidir quando usar a ferramenta. Seja específico sobre o que a ferramenta faz e quando ela deve ser chamada.</Note>diff --git a/packages/twenty-docs/l/pt/user-guide/workflows/capabilities/use-iterator.mdx b/packages/twenty-docs/l/pt/user-guide/workflows/capabilities/use-iterator.mdxindex 51b29a782bc..b42b66771de 100644--- a/packages/twenty-docs/l/pt/user-guide/workflows/capabilities/use-iterator.mdx+++ b/packages/twenty-docs/l/pt/user-guide/workflows/capabilities/use-iterator.mdx@@ -23,6 +23,12 @@ O Iterador espera um **array** como entrada. Em seguida:3. Passa para o item seguinte4. Repete até que todos os itens sejam processados+### Selecionar o array para iterar++A maioria das origens de arrays (Search Records, um campo de array de webhook, um gatilho manual em massa) pode ser selecionada diretamente no seletor de variáveis.++Quando uma etapa de **Code** ou **Logic Function** retorna um *array de nível superior*, sua saída aparece no seletor de variáveis como entradas indexadas (`0`, `1`, `2`, …). Para iterar sobre o array como um todo, selecione a opção **Whole list** para essa etapa — o Iterator então deduz automaticamente o formato de cada item a partir da lista.+## Configuração básica### Exemplo: Enviar e-mail a todos nos resultados da pesquisa@@ -77,6 +83,8 @@ Dentro do Iterador, use `{{iterator.currentItem}}` para aceder ao registo atual:| `{{iterator.currentItem.company.name}}` | Nome da empresa relacionada || `{{iterator.index}}` | Posição atual no array (base 0) |+No seletor de variáveis, você pode detalhar um campo específico do item atual ou escolher **Use the whole item** para fazer referência ao item atual inteiro (`{{iterator.currentItem}}`). Selecionar o item inteiro é útil quando você quer passar um registro completo diretamente para uma etapa subsequente, em vez de reconstruí-lo campo por campo.+## Padrões comuns### Atualizar vários registosdiff --git a/packages/twenty-docs/l/pt/user-guide/workflows/capabilities/workflow-actions.mdx b/packages/twenty-docs/l/pt/user-guide/workflows/capabilities/workflow-actions.mdxindex 3a62355ff4d..242616fb434 100644--- a/packages/twenty-docs/l/pt/user-guide/workflows/capabilities/workflow-actions.mdx+++ b/packages/twenty-docs/l/pt/user-guide/workflows/capabilities/workflow-actions.mdx@@ -112,7 +112,7 @@ Cria um novo registro ou atualiza um existente com base em critérios de corresp**Configuração**:-* Selecione o array de registros de uma etapa anterior (por exemplo, resultados de Search Records, de um gatilho Manual com Bulk, de um nó de código)+* Selecione o array de registros de uma etapa anterior (por exemplo, resultados de Search Records, de um gatilho Manual com Bulk, de um nó de código). Quando uma etapa de código ou de função lógica retorna um array de nível superior, selecione a opção **Whole list** para iterar por toda a saída.* Defina as ações a serem realizadas em cada registro no loop.<Note>@@ -120,7 +120,7 @@ Cria um novo registro ou atualiza um existente com base em critérios de corresp- Ao usar ramificações dentro de um iterador, certifique-se de que a última etapa de cada ramificação se conecte de volta ao iterador para fechar o loop.</Note>-* Acesse os campos de `Current Item`: para usar campos do registro que está sendo processado no momento, clique na etapa **Iterator** e, em seguida, selecione **Current item**. A lista de campos disponíveis desse registro será exibida e poderá ser selecionada para uso em ações subsequentes.+* Acesse os campos de `Current Item`: para usar campos do registro que está sendo processado no momento, clique na etapa **Iterator** e, em seguida, selecione **Current item**. A lista de campos disponíveis desse registro será exibida e poderá ser selecionada para uso em ações subsequentes. Você também pode selecionar **Use the whole item** para passar o item atual inteiro para uma etapa posterior.<VimeoEmbed videoId="1146577247" title="Demonstração em vídeo" />@@ -245,6 +245,8 @@ Os campos não podem ser tornados obrigatórios.Executa JavaScript personalizado dentro do seu fluxo de trabalho.+Nos bastidores, cada ação de código é respaldada por sua própria **função lógica** — uma função TypeScript do lado do servidor que é executada na plataforma Twenty. Quando você adiciona uma ação de código, o Twenty cria uma função lógica dedicada para essa etapa e exibe seu editor em linha, de modo que o código que você escreve fica junto com o fluxo de trabalho.+**Configuração**:* Acesse variáveis de etapas anteriores. Você pode editar os nomes das variáveis dinamicamente.@@ -267,6 +269,25 @@ Se você precisar usar chaves de API externas em seu código, deverá inseri-lasClique no ícone quadrado no canto superior direito do editor de código para exibi-lo em tela cheia — útil, já que a largura padrão do editor é limitada.</Tip>+#### Reutilizar uma função lógica em vários fluxos de trabalho++A ação de código em linha é ótima para lógica pontual, mas o código que ela contém pertence apenas àquela etapa. Quando você quiser compartilhar a mesma lógica em vários fluxos de trabalho — ou mantê-la como código-fonte versionado em um aplicativo — defina uma **função lógica reutilizável** em vez de copiar e colar código em cada ação de código.++Uma função lógica é definida uma vez em um aplicativo (usando o `defineLogicFunction` do SDK) e exposta ao construtor de fluxos de trabalho ao adicionar `workflowActionTriggerSettings`. Depois que seu aplicativo é instalado, essa função aparece como uma ação própria no construtor de fluxos de trabalho, ao lado das ações nativas. Ao selecioná-la, são renderizados os campos de entrada que você declarou (com seletores de variáveis, assim como outras ações) e o seu código compartilhado é executado — sem necessidade de JavaScript inline.++| | Ação de código | Função lógica reutilizável |+| ---------------------- | ----------------------------------------------------------- | -------------------------------------------------------------------- |+| **Onde o código fica** | Editor em linha, vinculado a uma etapa do fluxo de trabalho | Definida em um app, versionada no controle de código-fonte |+| **Reutilização** | Copiada e colada em cada etapa | Adicionada como uma ação em qualquer fluxo de trabalho |+| **Entradas** | Variáveis conectadas no editor | Campos renderizados a partir do esquema de entrada que você declarou |+| **Melhor para** | Lógica rápida e específica do fluxo de trabalho | Lógica compartilhada usada em vários fluxos de trabalho |++Ambas são executadas no mesmo tempo de execução da função lógica; portanto, uma ação de código que você prototipou em linha pode posteriormente ser promovida a uma função lógica reutilizável com mudanças mínimas.++<Tip>+Para a documentação de referência voltada para desenvolvedores sobre como definir funções lógicas e expô-las no construtor de fluxos de trabalho, consulte [Logic Functions](/l/pt/developers/extend/apps/logic/logic-functions) — em particular a seção **Exposing a function as an AI tool or workflow action** e `workflowActionTriggerSettings`.+</Tip>+### Requisição HTTPEnvia uma solicitação para uma API externa como parte do seu fluxo de trabalho.diff --git a/packages/twenty-docs/l/pt/user-guide/workflows/how-tos/advanced-configurations/handle-arrays-in-code-actions.mdx b/packages/twenty-docs/l/pt/user-guide/workflows/how-tos/advanced-configurations/handle-arrays-in-code-actions.mdxindex 237a09d0281..cd8509fe891 100644--- a/packages/twenty-docs/l/pt/user-guide/workflows/how-tos/advanced-configurations/handle-arrays-in-code-actions.mdx+++ b/packages/twenty-docs/l/pt/user-guide/workflows/how-tos/advanced-configurations/handle-arrays-in-code-actions.mdx@@ -73,9 +73,9 @@ export const main = async (params: {O nó de Código retorna um objeto estruturado em vez de um array. Nas etapas subsequentes, agora você pode selecionar campos individuais como `answer.firstname` e `answer.name` no seletor de variáveis.-<Note>-Estamos trabalhando ativamente para tornar o tratamento de arrays mais fácil em atualizações futuras.-</Note>+<Tip>+**Quer iterar sobre o array em vez de extrair campos?** Quando uma etapa Code ou Logic Function retorna um array de nível superior, você pode passá-lo diretamente para um [Iterator](/l/pt/user-guide/workflows/capabilities/use-iterator): selecione a opção **Whole list** da etapa como entrada do Iterator e, em seguida, faça referência a cada elemento com `{{iterator.currentItem}}` dentro do loop. Nesse caso, você não precisa reestruturar o array em um objeto.+</Tip><Tip>Clique no ícone quadrado no canto superior direito do editor de código para exibi-lo em tela cheia — útil, já que a largura padrão do editor é limitada.diff --git a/packages/twenty-docs/l/ro/developers/extend/apps/logic/logic-functions.mdx b/packages/twenty-docs/l/ro/developers/extend/apps/logic/logic-functions.mdxindex 05e094a59d8..74462829e1c 100644--- a/packages/twenty-docs/l/ro/developers/extend/apps/logic/logic-functions.mdx+++ b/packages/twenty-docs/l/ro/developers/extend/apps/logic/logic-functions.mdx@@ -412,6 +412,10 @@ Funcțiile logice pot fi expuse în două locuri, fiecare cu propriul declanșatO funcție poate opta pentru una, cealaltă sau ambele. Acestea stau alături de `cronTriggerSettings`, `databaseEventTriggerSettings` și `httpRouteTriggerSettings` — același tipar, aceeași formă.+<Note>+**Relația cu acțiunea Code din fluxul de lucru.** Acțiunea integrată **Code** din constructorul de fluxuri de lucru este ea însăși o funcție logică — Twenty creează câte una pentru fiecare pas Code și afișează editorul inline. `workflowActionTriggerSettings` este modul în care transformi acel cod inline, de unică folosință, într-o acțiune **reutilizabilă**: definești funcția o singură dată în aplicația ta și devine selectabilă în orice flux de lucru, în loc să fie copiată și lipită în fiecare pas Code. Vezi [acțiunea Code](/l/ro/user-guide/workflows/capabilities/workflow-actions#code) în ghidul utilizatorului pentru vizualizarea din perspectiva utilizatorului final.+</Note>+```ts src/logic-functions/enrich-company.logic-function.tsimport { defineLogicFunction } from 'twenty-sdk/define';import { CoreApiClient } from 'twenty-client-sdk/core';@@ -497,6 +501,77 @@ export default defineLogicFunction({});```+##### Un exemplu complet de acțiune de flux de lucru++`workflowActionTriggerSettings` acceptă patru câmpuri:++| Câmp | Scop |+| -------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |+| `label` | Numele afișat pentru acțiune în selectorul de pași al constructorului de fluxuri de lucru. Implicit, este `name` al funcției. |+| `icon` | Pictograma afișată lângă acțiune (un nume `tabler-icons`, de ex. `IconBuilding`). |+| `inputSchema` | `InputSchema` avansat al Twenty — ceea ce constructorul afișează ca câmpuri configurabile (cu selectoare de variabile). Opțional; dedus din handler atunci când este omis. |+| `outputSchema` | Declară structura returnată de handler, astfel încât **pașii următori să poată mapa la câmpurile de ieșire ale acesteia**. Opțional; fără acesta, ieșirea este expusă ca o singură valoare opacă. |++Reunind totul — o funcție expusă ca o acțiune de flux de lucru, cu o ieșire declarată astfel încât pașii următori să poată face referire la `taskId`:++```ts src/logic-functions/enrich-company.logic-function.ts+import { defineLogicFunction } from 'twenty-sdk/define';+import { jsonSchemaToInputSchema, type InputJsonSchema } from 'twenty-sdk/logic-function';+import { CoreApiClient } from 'twenty-client-sdk/core';++const inputSchema: InputJsonSchema = {+ type: 'object',+ properties: {+ companyName: { type: 'string', label: 'Company name' },+ domain: { type: 'string', label: 'Domain' },+ },+ required: ['companyName'],+};++const handler = async (params: { companyName: string; domain?: string }) => {+ const client = new CoreApiClient();++ const result = await client.mutation({+ createTask: {+ __args: {+ data: {+ title: `Enrich data for ${params.companyName}`,+ body: `Domain: ${params.domain ?? 'unknown'}`,+ },+ },+ id: true,+ },+ });++ // The keys returned here should match the `outputSchema` properties below.+ return { taskId: result.createTask.id, enriched: true };+};++export default defineLogicFunction({+ universalIdentifier: 'f47ac10b-58cc-4372-a567-0e02b2c3d479',+ name: 'enrich-company',+ description: 'Enrich a company record with external data',+ timeoutSeconds: 10,+ handler,+ workflowActionTriggerSettings: {+ label: 'Enrich Company',+ icon: 'IconBuilding',+ inputSchema: jsonSchemaToInputSchema(inputSchema),+ outputSchema: [+ {+ type: 'object',+ properties: {+ taskId: { type: 'string' },+ enriched: { type: 'boolean' },+ },+ },+ ],+ },+});+```++Odată ce aplicația este instalată, **Enrich Company** apare în selectorul de acțiuni al constructorului de fluxuri de lucru. Constructorul afișează `companyName` și `domain` ca câmpuri de intrare (fiecare putând prelua valori din pașii anteriori), iar pașii ulteriori pot face referire la ieșirile `taskId` și `enriched` ale pasului.+<Note>**Scrieți o `description` bună.** Agenții AI se bazează pe câmpul `description` al funcției pentru a decide când să folosească instrumentul. Fiți specifici cu privire la ceea ce face instrumentul și când ar trebui apelat.</Note>diff --git a/packages/twenty-docs/l/ro/user-guide/workflows/capabilities/use-iterator.mdx b/packages/twenty-docs/l/ro/user-guide/workflows/capabilities/use-iterator.mdxindex b36b3a329d8..6e72f2082aa 100644--- a/packages/twenty-docs/l/ro/user-guide/workflows/capabilities/use-iterator.mdx+++ b/packages/twenty-docs/l/ro/user-guide/workflows/capabilities/use-iterator.mdx@@ -23,6 +23,12 @@ Iterator așteaptă un **array** ca intrare. Apoi:3. Trece la următorul element4. Repetă până când toate elementele sunt procesate+### Selectarea tabloului peste care să se itereze++Majoritatea surselor de tablouri (Search Records, un câmp de tablou dintr-un webhook, un declanșator manual Bulk) pot fi selectate direct în selectorul de variabile.++Când un pas de tip **Code** sau **Logic Function** returnează un *tablou de nivel superior*, rezultatul său apare în selectorul de variabile ca intrări indexate (`0`, `1`, `2`, …). Pentru a itera peste întregul tablou, selectează opțiunea **Whole list** pentru acel pas — Iteratorul deduce apoi automat structura fiecărui element din listă.+## Configurare de bază### Exemplu: Trimiteți e-mail tuturor din rezultatele căutării@@ -77,6 +83,8 @@ Dacă Search Records returnează 5 persoane, Iteratorul:| `{{iterator.currentItem.company.name}}` | Numele companiei asociate || `{{iterator.index}}` | Poziția curentă în array (indexare de la 0) |+În selectorul de variabile, poți fie să intri într-un câmp specific al elementului curent, fie să alegi **Use the whole item** pentru a face referire la întregul element curent (`{{iterator.currentItem}}`). Selectarea întregului element este utilă atunci când vrei să transmiți o înregistrare completă direct într-un pas ulterior, în loc să o reconstruiești câmp cu câmp.+## Tipare comune### Actualizați mai multe înregistrăridiff --git a/packages/twenty-docs/l/ro/user-guide/workflows/capabilities/workflow-actions.mdx b/packages/twenty-docs/l/ro/user-guide/workflows/capabilities/workflow-actions.mdxindex 1e77081b732..3a2025eacc6 100644--- a/packages/twenty-docs/l/ro/user-guide/workflows/capabilities/workflow-actions.mdx+++ b/packages/twenty-docs/l/ro/user-guide/workflows/capabilities/workflow-actions.mdx@@ -112,7 +112,7 @@ Creează o înregistrare nouă sau actualizează una existentă pe baza criterii**Configurare**:-* Selectați array-ul de înregistrări dintr-un pas anterior (de ex., rezultate din Search Records, dintr-un declanșator Manual cu disponibilitate Bulk, dintr-un nod de cod)+* Selectați array-ul de înregistrări dintr-un pas anterior (de ex., rezultate din Search Records, dintr-un declanșator Manual cu disponibilitate Bulk, dintr-un nod de cod). Când un pas de tip Cod sau funcție logică returnează un array de nivel superior, selectează opțiunea **Whole list** pentru a itera peste întregul rezultat.* Definiți acțiunile de efectuat pe fiecare înregistrare în buclă.<Note>@@ -120,7 +120,7 @@ Creează o înregistrare nouă sau actualizează una existentă pe baza criterii- Când folosiți ramuri în interiorul unui iterator, asigurați-vă că ultimul pas al fiecărei ramuri se conectează înapoi la iterator pentru a închide bucla.</Note>-* Accesați câmpurile `Current Item`: pentru a utiliza câmpuri din înregistrarea procesată în prezent, faceți clic pe pasul **Iterator**, apoi selectați **Current item**. Lista câmpurilor disponibile din acea înregistrare va fi afișată și poate fi selectată pentru utilizare în acțiunile ulterioare.+* Accesați câmpurile `Current Item`: pentru a utiliza câmpuri din înregistrarea procesată în prezent, faceți clic pe pasul **Iterator**, apoi selectați **Current item**. Lista câmpurilor disponibile din acea înregistrare va fi afișată și poate fi selectată pentru utilizare în acțiunile ulterioare. Poți, de asemenea, să selectezi **Use the whole item** pentru a trimite întregul element curent într-un pas ulterior.<VimeoEmbed videoId="1146577247" title="Demonstrație video" />@@ -245,6 +245,8 @@ Câmpurile nu pot fi făcute obligatorii.Rulați JavaScript personalizat în cadrul fluxului dumneavoastră de lucru.+În fundal, fiecare acțiune de cod este susținută de propria **funcție logică** — o funcție TypeScript pe server, care rulează pe platforma Twenty. Când adaugi o acțiune de cod, Twenty creează o funcție logică dedicată pentru acel pas și îi afișează editorul inline, astfel încât codul pe care îl scrii rămâne asociat cu workflow-ul.+**Configurare**:* Accesați variabilele din pașii anteriori. Puteți edita dinamic numele variabilelor.@@ -267,6 +269,25 @@ Dacă trebuie să utilizați chei API externe în codul dvs., trebuie să le intFaceți clic pe pictograma pătrată din dreapta sus a editorului de cod pentru a-l afișa pe tot ecranul — util, deoarece lățimea implicită a editorului este limitată.</Tip>+#### Reutilizarea unei funcții logice între workflow-uri++Acțiunea de cod inline este excelentă pentru logică ad-hoc, dar codul pe care îl conține aparține acelui singur pas. Când vrei să partajezi aceeași logică între mai multe workflow-uri — sau să o menții ca sursă versionată într-o aplicație — definește o **funcție logică reutilizabilă** în loc să copiezi și să lipești cod în fiecare acțiune de cod.++O funcție logică este definită o singură dată într-o aplicație (folosind `defineLogicFunction` din SDK) și expusă în constructorul de workflow prin adăugarea `workflowActionTriggerSettings`. După ce aplicația ta este instalată, acea funcție apare ca acțiune separată în constructorul de workflow, alături de acțiunile încorporate. Selectarea acesteia afișează câmpurile de intrare pe care le-ai declarat (cu selectoare de variabile, la fel ca alte acțiuni) și rulează codul tău partajat — fără a fi necesar JavaScript inline.++| | Acțiune de cod | Funcție logică reutilizabilă |+| ---------------------------------- | ------------------------------------------------------ | ---------------------------------------------------------------------- |+| **Locul în care „trăiește” codul** | Editor inline, legat de un singur pas al workflow-ului | Definită într-o aplicație, versionată în sistemul de control al sursei |+| **Reutilizare** | Copiat și lipit pentru fiecare pas | Adăugată ca acțiune în orice workflow |+| **Intrări** | Variabile conectate în editor | Câmpuri afișate pe baza schemei de intrare declarate |+| **Cel mai potrivit pentru** | Logică rapidă, specifică workflow-ului | Logică partajată, folosită în mai multe workflow-uri |++Ambele rulează pe același runtime pentru funcții logice, astfel încât o acțiune de cod pe care ai prototipat-o inline poate fi ulterior promovată într-o funcție logică reutilizabilă cu modificări minime.++<Tip>+Pentru documentația destinată dezvoltatorilor privind definirea funcțiilor logice și expunerea lor în constructorul de workflow, consultă [Logic Functions](/l/ro/developers/extend/apps/logic/logic-functions) — în special secțiunea **Exposing a function as an AI tool or workflow action** și `workflowActionTriggerSettings`.+</Tip>+### Solicitare HTTPTrimite o cerere la un API extern ca parte a fluxului dumneavoastră de lucru.diff --git a/packages/twenty-docs/l/ro/user-guide/workflows/how-tos/advanced-configurations/handle-arrays-in-code-actions.mdx b/packages/twenty-docs/l/ro/user-guide/workflows/how-tos/advanced-configurations/handle-arrays-in-code-actions.mdxindex d36d0fe8e22..85a6987e418 100644--- a/packages/twenty-docs/l/ro/user-guide/workflows/how-tos/advanced-configurations/handle-arrays-in-code-actions.mdx+++ b/packages/twenty-docs/l/ro/user-guide/workflows/how-tos/advanced-configurations/handle-arrays-in-code-actions.mdx@@ -73,9 +73,9 @@ export const main = async (params: {Nodul de cod returnează un obiect structurat în locul unui tablou. În pașii următori, acum puteți selecta câmpuri individuale precum `answer.firstname` și `answer.name` din selectorul de variabile.-<Note>-Lucrăm activ pentru a simplifica gestionarea tablourilor în actualizările viitoare.-</Note>+<Tip>+**Vrei să iterezi peste array în loc să extragi câmpuri?** Când un pas Code sau Logic Function returnează un array de nivel superior, îl poți trimite direct într-un [Iterator](/l/ro/user-guide/workflows/capabilities/use-iterator): selectează opțiunea pasului **Whole list** ca intrare pentru Iterator, apoi fă referire la fiecare element cu `{{iterator.currentItem}}` în interiorul buclei. În acest caz nu este nevoie să restructurezi array-ul într-un obiect.+</Tip><Tip>Faceți clic pe pictograma pătrată din dreapta sus a editorului de cod pentru a-l afișa pe tot ecranul — util, deoarece lățimea implicită a editorului este limitată.diff --git a/packages/twenty-docs/l/ru/developers/extend/apps/logic/logic-functions.mdx b/packages/twenty-docs/l/ru/developers/extend/apps/logic/logic-functions.mdxindex 5aec5b88aee..cf7d445bb5c 100644--- a/packages/twenty-docs/l/ru/developers/extend/apps/logic/logic-functions.mdx+++ b/packages/twenty-docs/l/ru/developers/extend/apps/logic/logic-functions.mdx@@ -411,6 +411,10 @@ const handler = async (event: PersonDestroyedEvent) => {Функция может выбрать один, другой или оба варианта. Они идут рядом с `cronTriggerSettings`, `databaseEventTriggerSettings` и `httpRouteTriggerSettings` — тот же шаблон, та же структура.+<Note>+**Связь с действием Code рабочего процесса.** Встроенное действие **Code** в конструкторе рабочих процессов само по себе является логической функцией — Twenty создаёт по одной на каждый шаг Code и отображает его редактор встроенным образом. `workflowActionTriggerSettings` — это способ превратить разовый встроенный код в **повторно используемое** действие: определите функцию один раз в своём приложении, и она станет доступной для выбора в любом рабочем процессе, вместо копирования и вставки в каждый шаг Code. См. [действие Code](/l/ru/user-guide/workflows/capabilities/workflow-actions#code) в руководстве пользователя, чтобы увидеть, как это выглядит для конечного пользователя.+</Note>+```ts src/logic-functions/enrich-company.logic-function.tsimport { defineLogicFunction } from 'twenty-sdk/define';import { CoreApiClient } from 'twenty-client-sdk/core';@@ -496,6 +500,77 @@ export default defineLogicFunction({});```+##### Полный пример действия рабочего процесса++`workflowActionTriggerSettings` принимает четыре поля:++| Поле | Назначение |+| -------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |+| `label` | Имя, отображаемое для действия в селекторе шагов конструктора рабочих процессов. По умолчанию используется `name` функции. |+| `icon` | Иконка, отображаемая рядом с действием (имя из `tabler-icons`, например, `IconBuilding`). |+| `inputSchema` | Расширенная схема ввода (`InputSchema`) Twenty — то, что конструктор отображает как настраиваемые поля (с выбором переменных). Необязательно; при отсутствии выводится из обработчика. |+| `outputSchema` | Определяет структуру, которую возвращает обработчик, чтобы **последующие шаги могли сопоставлять свои данные с его выходными полями**. Необязательно; без неё вывод представлен одним непрозрачным значением. |++Объединяя всё вместе — функция, представленная как действие рабочего процесса, с объявленным выходом, чтобы последующие шаги могли ссылаться на `taskId`:++```ts src/logic-functions/enrich-company.logic-function.ts+import { defineLogicFunction } from 'twenty-sdk/define';+import { jsonSchemaToInputSchema, type InputJsonSchema } from 'twenty-sdk/logic-function';+import { CoreApiClient } from 'twenty-client-sdk/core';++const inputSchema: InputJsonSchema = {+ type: 'object',+ properties: {+ companyName: { type: 'string', label: 'Company name' },+ domain: { type: 'string', label: 'Domain' },+ },+ required: ['companyName'],+};++const handler = async (params: { companyName: string; domain?: string }) => {+ const client = new CoreApiClient();++ const result = await client.mutation({+ createTask: {+ __args: {+ data: {+ title: `Enrich data for ${params.companyName}`,+ body: `Domain: ${params.domain ?? 'unknown'}`,+ },+ },+ id: true,+ },+ });++ // The keys returned here should match the `outputSchema` properties below.+ return { taskId: result.createTask.id, enriched: true };+};++export default defineLogicFunction({+ universalIdentifier: 'f47ac10b-58cc-4372-a567-0e02b2c3d479',+ name: 'enrich-company',+ description: 'Enrich a company record with external data',+ timeoutSeconds: 10,+ handler,+ workflowActionTriggerSettings: {+ label: 'Enrich Company',+ icon: 'IconBuilding',+ inputSchema: jsonSchemaToInputSchema(inputSchema),+ outputSchema: [+ {+ type: 'object',+ properties: {+ taskId: { type: 'string' },+ enriched: { type: 'boolean' },+ },+ },+ ],+ },+});+```++После установки приложения **Enrich Company** появляется в селекторе действий конструктора рабочих процессов. Конструктор отображает `companyName` и `domain` как поля ввода (каждое может получать значения из предыдущих шагов), а последующие шаги могут ссылаться на выходные значения шага `taskId` и `enriched`.+<Note>**Напишите хорошее описание в поле `description`.** Агенты ИИ опираются на поле `description` функции, чтобы решить, когда использовать инструмент. Чётко опишите, что делает инструмент и когда его следует вызывать.</Note>diff --git a/packages/twenty-docs/l/ru/user-guide/workflows/capabilities/use-iterator.mdx b/packages/twenty-docs/l/ru/user-guide/workflows/capabilities/use-iterator.mdxindex a492e6d3a0a..317fbb7c015 100644--- a/packages/twenty-docs/l/ru/user-guide/workflows/capabilities/use-iterator.mdx+++ b/packages/twenty-docs/l/ru/user-guide/workflows/capabilities/use-iterator.mdx@@ -23,6 +23,12 @@ description: Перебирайте массивы записей и выпол3. Переходит к следующему элементу4. Повторяет, пока все элементы не будут обработаны+### Выбор массива для перебора++Большинство источников массивов (Search Records, поле массива вебхука, ручной триггер Bulk) можно выбрать непосредственно в селекторе переменных.++Когда шаг **Code** или **Logic Function** возвращает *массив верхнего уровня*, его вывод отображается в селекторе переменных как индексированные элементы (`0`, `1`, `2`, …). Чтобы перебирать массив целиком, выберите для этого шага параметр **Whole list** — тогда Iterator автоматически определит структуру каждого элемента списка.+## Базовая настройка### Пример: отправка письма всем из результатов поиска@@ -77,6 +83,8 @@ description: Перебирайте массивы записей и выпол| `{{iterator.currentItem.company.name}}` | Название связанной компании || `{{iterator.index}}` | Текущая позиция в массиве (с нуля) |+В селекторе переменных вы можете либо перейти к конкретному полю текущего элемента, либо выбрать **Use the whole item**, чтобы сослаться на весь текущий элемент (`{{iterator.currentItem}}`). Выбор всего элемента удобен, когда вы хотите передать полную запись непосредственно в следующий шаг по цепочке, вместо того чтобы заново собирать ее по полям.+## Типовые шаблоны### Обновление нескольких записейdiff --git a/packages/twenty-docs/l/ru/user-guide/workflows/capabilities/workflow-actions.mdx b/packages/twenty-docs/l/ru/user-guide/workflows/capabilities/workflow-actions.mdxindex 8b20bd7d125..5f970051862 100644--- a/packages/twenty-docs/l/ru/user-guide/workflows/capabilities/workflow-actions.mdx+++ b/packages/twenty-docs/l/ru/user-guide/workflows/capabilities/workflow-actions.mdx@@ -112,7 +112,7 @@ import { VimeoEmbed } from '/snippets/vimeo-embed.mdx';**Настройка**:-* Выберите массив записей с предыдущего шага (например, результаты из Search Records, из Manual trigger with Bulk availability, из code node)+* Выберите массив записей с предыдущего шага (например, результаты из Search Records, из Manual trigger with Bulk availability, из code node). Когда шаг Code или «Логическая функция» возвращает массив верхнего уровня, выберите параметр **Whole list**, чтобы выполнить цикл по всему результату.* Определите действия, которые нужно выполнить для каждой записи в цикле.<Note>@@ -120,7 +120,7 @@ import { VimeoEmbed } from '/snippets/vimeo-embed.mdx';- При использовании ветвлений внутри итератора убедитесь, что последний шаг каждой ветки возвращается к итератору, чтобы замкнуть цикл.</Note>-* Доступ к полям `Current Item`: чтобы использовать поля записи, которая обрабатывается в данный момент, нажмите на шаг **Iterator**, затем выберите **Current item**. Будет отображен список доступных полей этой записи, и их можно выбрать для использования в последующих действиях.+* Доступ к полям `Current Item`: чтобы использовать поля записи, которая обрабатывается в данный момент, нажмите на шаг **Iterator**, затем выберите **Current item**. Будет отображен список доступных полей этой записи, и их можно выбрать для использования в последующих действиях. Вы также можете выбрать **Use the whole item**, чтобы передать весь текущий элемент на следующий шаг.<VimeoEmbed videoId="1146577247" title="Видеодемонстрация" />@@ -245,6 +245,8 @@ import { VimeoEmbed } from '/snippets/vimeo-embed.mdx';Выполняет кастомный JavaScript в вашем рабочем процессе.+Под капотом каждое действие Code поддерживается собственной **логической функцией** — серверной функцией на TypeScript, которая выполняется на платформе Twenty. Когда вы добавляете действие Code, Twenty создает для этого шага отдельную логическую функцию и открывает ее редактор прямо в интерфейсе, поэтому написанный вами код хранится вместе с рабочим процессом.+**Настройка**:* Получайте доступ к переменным из предыдущих шагов. Вы можете динамически изменять имена переменных.@@ -267,6 +269,25 @@ import { VimeoEmbed } from '/snippets/vimeo-embed.mdx';Нажмите квадратный значок в правом верхнем углу редактора кода, чтобы отобразить его на весь экран — это полезно, поскольку ширина редактора по умолчанию ограничена.</Tip>+#### Повторное использование логической функции в рабочих процессах++Встроенное действие Code отлично подходит для разовой логики, но код, который оно содержит, принадлежит только этому одному шагу. Когда вы хотите использовать одну и ту же логику в нескольких рабочих процессах — или вести ее как версионируемый исходный код в приложении — определите **повторно используемую логическую функцию** вместо копирования и вставки кода в каждое действие Code.++Логическая функция определяется один раз в приложении (с помощью SDK-функции `defineLogicFunction`) и становится доступной в конструкторе рабочих процессов при добавлении `workflowActionTriggerSettings`. После установки вашего приложения эта функция появляется как отдельное действие в конструкторе рабочих процессов, наряду со встроенными действиями. При выборе этого действия отображаются объявленные вами поля ввода (с селекторами переменных, как и в других действиях) и выполняется ваш общий код — встроенный JavaScript не требуется.++| | Действие Code | Повторно используемая логическая функция |+| ---------------------------- | ---------------------------------------------------------------- | ----------------------------------------------------------------- |+| **Где «живет» код** | Встроенный редактор, привязанный к одному шагу рабочего процесса | Определена в приложении, версионируется в системе контроля версий |+| **Повторное использование** | Копируется и вставляется для каждого шага | Добавляется как действие в любой рабочий процесс |+| **Вводы** | Переменные, подключенные в редакторе | Поля, отображаемые из объявленной вами схемы ввода |+| **Лучше всего подходит для** | Быстрая логика, специфичная для рабочего процесса | Общая логика, используемая в нескольких рабочих процессах |++Оба варианта работают в одной и той же среде выполнения логических функций, поэтому действие Code, которое вы прототипировали во встроенном режиме, позже можно с минимальными изменениями превратить в повторно используемую логическую функцию.++<Tip>+Разработчикам, которым нужна документация по определению логических функций и их публикации в конструкторе рабочих процессов, следует обратиться к разделу [Logic Functions](/l/ru/developers/extend/apps/logic/logic-functions) — в частности, к разделу **Exposing a function as an AI tool or workflow action** и настройкам `workflowActionTriggerSettings`.+</Tip>+### HTTP-запросОтправляет запрос внешнему API в рамках вашего рабочего процесса.diff --git a/packages/twenty-docs/l/ru/user-guide/workflows/how-tos/advanced-configurations/handle-arrays-in-code-actions.mdx b/packages/twenty-docs/l/ru/user-guide/workflows/how-tos/advanced-configurations/handle-arrays-in-code-actions.mdxindex 1e9b4a20145..c173b55ee51 100644--- a/packages/twenty-docs/l/ru/user-guide/workflows/how-tos/advanced-configurations/handle-arrays-in-code-actions.mdx+++ b/packages/twenty-docs/l/ru/user-guide/workflows/how-tos/advanced-configurations/handle-arrays-in-code-actions.mdx@@ -73,9 +73,9 @@ export const main = async (params: {Узел Code возвращает структурированный объект вместо массива. На последующих шагах теперь можно выбирать отдельные поля, такие как `answer.firstname` и `answer.name`, в селекторе переменных.-<Note>-Мы активно работаем над упрощением работы с массивами в будущих обновлениях.-</Note>+<Tip>+**Хотите перебирать массив в цикле вместо извлечения полей?** Когда шаг Code или Logic Function возвращает массив верхнего уровня, вы можете передать его напрямую в [Iterator](/l/ru/user-guide/workflows/capabilities/use-iterator): выберите параметр шага **Whole list** в качестве входных данных Iterator, а затем обращайтесь к каждому элементу с помощью `{{iterator.currentItem}}` внутри цикла. В этом случае вам не нужно преобразовывать массив в объект.+</Tip><Tip>Нажмите квадратный значок в правом верхнем углу редактора кода, чтобы отобразить его на весь экран — это полезно, поскольку ширина редактора по умолчанию ограничена.diff --git a/packages/twenty-docs/l/tr/developers/extend/apps/logic/logic-functions.mdx b/packages/twenty-docs/l/tr/developers/extend/apps/logic/logic-functions.mdxindex 7b1d7f9381c..f65c1d46cea 100644--- a/packages/twenty-docs/l/tr/developers/extend/apps/logic/logic-functions.mdx+++ b/packages/twenty-docs/l/tr/developers/extend/apps/logic/logic-functions.mdx@@ -412,6 +412,10 @@ Mantık işlevleri, her birinin kendi tetikleyicisi olacak şekilde iki yerde kuBir işlev bunlardan birini, diğerini veya her ikisini de tercih edebilir. Bunlar, `cronTriggerSettings`, `databaseEventTriggerSettings` ve `httpRouteTriggerSettings` ile birlikte yer alır — aynı desen, aynı biçim.+<Note>+**İş akışındaki Code eylemiyle ilişkisi.** İş akışı oluşturucusundaki yerleşik **Code** eylemi başlı başına bir mantık fonksiyonudur — Twenty, her Code adımı için bir tane oluşturur ve düzenleyicisini satır içi olarak sunar. `workflowActionTriggerSettings`, bu tek seferlik, satır içi kodu **yeniden kullanılabilir** bir eyleme dönüştürmenin yoludur: fonksiyonu uygulamanızda bir kez tanımlarsınız ve her Code adımına kopyalanıp yapıştırılmak yerine, herhangi bir iş akışı içinde seçilebilir hale gelir. Son kullanıcı görünümü için kullanıcı rehberindeki [Code eylemine](/l/tr/user-guide/workflows/capabilities/workflow-actions#code) bakın.+</Note>+```ts src/logic-functions/enrich-company.logic-function.tsimport { defineLogicFunction } from 'twenty-sdk/define';import { CoreApiClient } from 'twenty-client-sdk/core';@@ -497,6 +501,77 @@ export default defineLogicFunction({});```+##### Tam bir iş akışı eylemi örneği++`workflowActionTriggerSettings` dört alan kabul eder:++| Alan | Amaç |+| -------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |+| `label` | İş akışı oluşturucusunun adım seçicisinde eylem için gösterilen ad. Varsayılan olarak fonksiyon `name` değerini kullanır. |+| `icon` | Eylemin yanında gösterilen simge (`tabler-icons` adı, örn. `IconBuilding`). |+| `inputSchema` | Twenty'nin gelişmiş `InputSchema`'sı — oluşturucunun yapılandırılabilir alanlar (değişken seçicilerle birlikte) olarak render ettiği şey. İsteğe bağlıdır; belirtilmediğinde handler'dan çıkarılır. |+| `outputSchema` | Handler'ın döndürdüğü yapıyı tanımlar, böylece **sonraki adımlar çıktı alanlarına eşleme yapabilir**. İsteğe bağlıdır; olmadan, çıktı tek bir opak değer olarak sunulur. |++Tümünü bir araya getirme — bir iş akışı eylemi olarak sunulan bir fonksiyon; daha sonraki adımların `taskId` değerine referans verebilmesi için tanımlanmış bir çıktıyla birlikte:++```ts src/logic-functions/enrich-company.logic-function.ts+import { defineLogicFunction } from 'twenty-sdk/define';+import { jsonSchemaToInputSchema, type InputJsonSchema } from 'twenty-sdk/logic-function';+import { CoreApiClient } from 'twenty-client-sdk/core';++const inputSchema: InputJsonSchema = {+ type: 'object',+ properties: {+ companyName: { type: 'string', label: 'Company name' },+ domain: { type: 'string', label: 'Domain' },+ },+ required: ['companyName'],+};++const handler = async (params: { companyName: string; domain?: string }) => {+ const client = new CoreApiClient();++ const result = await client.mutation({+ createTask: {+ __args: {+ data: {+ title: `Enrich data for ${params.companyName}`,+ body: `Domain: ${params.domain ?? 'unknown'}`,+ },+ },+ id: true,+ },+ });++ // The keys returned here should match the `outputSchema` properties below.+ return { taskId: result.createTask.id, enriched: true };+};++export default defineLogicFunction({+ universalIdentifier: 'f47ac10b-58cc-4372-a567-0e02b2c3d479',+ name: 'enrich-company',+ description: 'Enrich a company record with external data',+ timeoutSeconds: 10,+ handler,+ workflowActionTriggerSettings: {+ label: 'Enrich Company',+ icon: 'IconBuilding',+ inputSchema: jsonSchemaToInputSchema(inputSchema),+ outputSchema: [+ {+ type: 'object',+ properties: {+ taskId: { type: 'string' },+ enriched: { type: 'boolean' },+ },+ },+ ],+ },+});+```++Uygulama kurulduktan sonra, **Enrich Company** iş akışı oluşturucusunun eylem seçicisinde görünür. Oluşturucu `companyName` ve `domain` alanlarını girdi alanları olarak render eder (her biri önceki adımlardan değer çekebilir) ve sonraki adımlar, adımın `taskId` ve `enriched` çıktılarına referans verebilir.+<Note>**İyi bir `description` yazın.** AI ajanları, aracı ne zaman kullanacaklarına karar vermek için işlevin `description` alanına güvenir. Aracın ne yaptığını ve ne zaman çağrılması gerektiğini açıkça belirtin.</Note>diff --git a/packages/twenty-docs/l/tr/user-guide/workflows/capabilities/use-iterator.mdx b/packages/twenty-docs/l/tr/user-guide/workflows/capabilities/use-iterator.mdxindex 77704a022c6..b20b1466acf 100644--- a/packages/twenty-docs/l/tr/user-guide/workflows/capabilities/use-iterator.mdx+++ b/packages/twenty-docs/l/tr/user-guide/workflows/capabilities/use-iterator.mdx@@ -23,6 +23,12 @@ Yineleyici, girdi olarak bir **dizi** bekler. Ardından:3. Sonraki öğeye geçer4. Tüm öğeler işlenene kadar tekrarlar+### Döngü yapılacak diziyi seçme++Çoğu dizi kaynağı (Kayıt Ara, bir webhook dizi alanı, Toplu manuel tetikleyici) doğrudan değişken seçicisinden seçilebilir.++Bir **Code** veya **Logic Function** adımı *üst düzey bir dizi* döndürdüğünde, çıktısı değişken seçicisinde indekslenmiş girişler (`0`, `1`, `2`, …) olarak görünür. Dizinin tamamında döngü yapmak için, ilgili adım için **Whole list** seçeneğini belirleyin — Iterator daha sonra listedeki her bir öğenin yapısını otomatik olarak belirler.+## Temel Kurulum### Örnek: Arama Sonuçlarındaki Herkese E-posta Gönderme@@ -77,6 +83,8 @@ Yineleyici içinde, geçerli kayda erişmek için `{{iterator.currentItem}}` kul| `{{iterator.currentItem.company.name}}` | İlgili şirket adı || `{{iterator.index}}` | Dizideki mevcut konum (0 tabanlı) |+Değişken seçicisinde, geçerli öğenin belirli bir alanına inebilir veya tüm geçerli öğeye (`{{iterator.currentItem}}`) başvurmak için **Use the whole item** seçeneğini seçebilirsiniz. Tüm öğeyi seçmek, bir kaydı alan alan yeniden oluşturmaktansa, tam haliyle doğrudan sonraki bir adıma iletmek istediğinizde kullanışlıdır.+## Yaygın Kalıplar### Birden Çok Kaydı Güncelleyindiff --git a/packages/twenty-docs/l/tr/user-guide/workflows/capabilities/workflow-actions.mdx b/packages/twenty-docs/l/tr/user-guide/workflows/capabilities/workflow-actions.mdxindex 69720362499..a7e7455b018 100644--- a/packages/twenty-docs/l/tr/user-guide/workflows/capabilities/workflow-actions.mdx+++ b/packages/twenty-docs/l/tr/user-guide/workflows/capabilities/workflow-actions.mdx@@ -112,7 +112,7 @@ Eşleştirme ölçütlerine göre yeni bir kayıt oluşturur veya mevcut bir kay**Yapılandırma**:-* Önceki bir adımdan gelen kayıt dizisini seçin (ör. Kayıt Ara sonuçları, Toplu kullanılabilirliğe sahip bir Manuel tetikleyici, bir kod düğümü)+* Önceki bir adımdan gelen kayıt dizisini seçin (ör. Kayıt Ara sonuçları, Toplu kullanılabilirliğe sahip bir Manuel tetikleyici, bir kod düğümü). Bir Code adımı veya mantık işlevi adımı üst düzey bir dizi döndürdüğünde, çıktının tamamı üzerinde döngü yapmak için **Tüm liste** seçeneğini seçin.* Döngüde her kayıt üzerinde gerçekleştireceğiniz işlemleri tanımlayın.<Note>@@ -120,7 +120,7 @@ Eşleştirme ölçütlerine göre yeni bir kayıt oluşturur veya mevcut bir kay- Bir yineleyici içinde dallar kullanırken, her dalın son adımının döngüyü kapatmak için yineleyiciye geri bağlandığından emin olun.</Note>-* `Current Item` Alanlarına Erişim: şu anda işlenen kayıttaki alanları kullanmak için **Iterator** adımına tıklayın, ardından **Current item** seçin. Bu kayıttan kullanılabilir alanların listesi görüntülenir ve sonraki eylemlerde kullanılmak üzere seçilebilir.+* `Current Item` Alanlarına Erişim: şu anda işlenen kayıttaki alanları kullanmak için **Iterator** adımına tıklayın, ardından **Current item** seçin. Bu kayıttan kullanılabilir alanların listesi görüntülenir ve sonraki eylemlerde kullanılmak üzere seçilebilir. Ayrıca, geçerli öğenin tamamını bir sonraki adıma aktarmak için **Öğenin tamamını kullan** seçeneğini de belirleyebilirsiniz.<VimeoEmbed videoId="1146577247" title="Video gösterimi" />@@ -245,6 +245,8 @@ Alanlar zorunlu hale getirilemez.İş akışınızda özel JavaScript çalıştırır.+Arka planda, her Code eylemi kendi **mantık işlevi** ile desteklenir — Twenty platformunda çalışan sunucu tarafı bir TypeScript işlevi. Bir Code eylemi eklediğinizde, Twenty o adım için özel bir mantık işlevi oluşturur ve düzenleyicisini satır içinde gösterir; böylece yazdığınız kod iş akışının parçası olur.+**Yapılandırma**:* Önceki adımlardan gelen değişkenlere erişin. Değişken adlarını dinamik olarak düzenleyebilirsiniz.@@ -267,6 +269,25 @@ Kodunuzda harici API anahtarlarını kullanmanız gerekiyorsa, bunları doğrudaKod düzenleyicisinin sağ üst kısmındaki kare simgeye tıklayarak tam ekranda görüntüleyin — varsayılan düzenleyici genişliği sınırlı olduğundan faydalıdır.</Tip>+#### İş akışları arasında bir mantık işlevini yeniden kullanma++Satır içi Code eylemi, tek seferlik mantık için harikadır, ancak içerdiği kod yalnızca o adıma aittir. Aynı mantığı birden fazla iş akışında paylaşmak — ya da bir uygulamada sürümlendirilen kaynak olarak korumak — istediğinizde, her Code eylemine kod kopyalayıp yapıştırmak yerine **yeniden kullanılabilir bir mantık işlevi** tanımlayın.++Bir mantık işlevi bir uygulamada bir kez tanımlanır (SDK'nin `defineLogicFunction` işlevi kullanılarak) ve `workflowActionTriggerSettings` eklenerek iş akışı oluşturucuya açığa çıkarılır. Uygulamanız yüklendikten sonra, bu işlev, yerleşik eylemlerin yanında, iş akışı oluşturucuda kendi eylemi olarak görünür. Onu seçmek, tanımladığınız giriş alanlarını (diğer eylemlerde olduğu gibi değişken seçicilerle birlikte) oluşturur ve paylaşılan kodunuzu çalıştırır — satır içi JavaScript gerekmez.++| | Code eylemi | Yeniden kullanılabilir mantık işlevi |+| ----------------------- | ----------------------------------------------------------- | ------------------------------------------------------------- |+| **Kodun bulunduğu yer** | Satır içi düzenleyici, tek bir iş akışı adımıyla bağlantılı | Bir uygulamada tanımlanır, kaynak kontrolünde sürümlendirilir |+| **Yeniden kullanım** | Her adım için kopyalanıp yapıştırılır | Herhangi bir iş akışına bir eylem olarak eklenir |+| **Girdiler** | Düzenleyicide bağlanan değişkenler | Tanımladığınız giriş şemasından oluşturulan alanlar |+| **En uygun** | Hızlı, iş akışına özgü mantık | Birden fazla iş akışında kullanılan paylaşılan mantık |++Her ikisi de aynı mantık işlevi çalışma zamanında çalışır; bu nedenle satır içinde prototipini oluşturduğunuz bir Code eylemi, minimum değişiklikle daha sonra yeniden kullanılabilir bir mantık işlevine yükseltilebilir.++<Tip>+Mantık işlevlerini tanımlama ve bunları iş akışı oluşturucuya açığa çıkarma konusunda geliştiricilere yönelik referans için, özellikle **Bir işlevi bir AI aracı veya iş akışı eylemi olarak açığa çıkarma** bölümü ve `workflowActionTriggerSettings` kısmı olmak üzere [Logic Functions](/l/tr/developers/extend/apps/logic/logic-functions) sayfasına bakın.+</Tip>+### HTTP İsteğiİş akışınızın bir parçası olarak harici bir API'ye istek gönderir.diff --git a/packages/twenty-docs/l/tr/user-guide/workflows/how-tos/advanced-configurations/handle-arrays-in-code-actions.mdx b/packages/twenty-docs/l/tr/user-guide/workflows/how-tos/advanced-configurations/handle-arrays-in-code-actions.mdxindex 64e43b94b5a..7fba2b98de0 100644--- a/packages/twenty-docs/l/tr/user-guide/workflows/how-tos/advanced-configurations/handle-arrays-in-code-actions.mdx+++ b/packages/twenty-docs/l/tr/user-guide/workflows/how-tos/advanced-configurations/handle-arrays-in-code-actions.mdx@@ -73,9 +73,9 @@ export const main = async (params: {Code düğümü bir dizi yerine yapılandırılmış bir nesne döndürür. Sonraki adımlarda, değişken seçiciden `answer.firstname` ve `answer.name` gibi tekil alanları artık seçebilirsiniz.-<Note>-Gelecek güncellemelerde diziyle çalışmayı kolaylaştırmak için aktif olarak çalışıyoruz.-</Note>+<Tip>+**Dizinin alanlarını çıkarmak yerine dizi üzerinde döngü yapmak mı istiyorsunuz?** Bir Code veya Logic Function adımı en üst düzeyde bir dizi döndürdüğünde, bunu doğrudan bir [Iterator](/l/tr/user-guide/workflows/capabilities/use-iterator) içine verebilirsiniz: Iterator'ın girdisi olarak adımın **Whole list** seçeneğini belirleyin ve ardından döngü içinde her bir öğeye `{{iterator.currentItem}}` ile başvurun. Bu durumda diziyi bir nesneye yeniden yapılandırmanız gerekmez.+</Tip><Tip>Kod düzenleyicisinin sağ üst kısmındaki kare simgeye tıklayarak tam ekranda görüntüleyin — varsayılan düzenleyici genişliği sınırlı olduğundan faydalıdır.diff --git a/packages/twenty-docs/l/zh/developers/extend/apps/logic/logic-functions.mdx b/packages/twenty-docs/l/zh/developers/extend/apps/logic/logic-functions.mdxindex 1feff8b0218..4461f7b4c6e 100644--- a/packages/twenty-docs/l/zh/developers/extend/apps/logic/logic-functions.mdx+++ b/packages/twenty-docs/l/zh/developers/extend/apps/logic/logic-functions.mdx@@ -412,6 +412,10 @@ const handler = async (event: PersonDestroyedEvent) => {函数可以选择加入其中一个、另一个,或两者都加入。 它们与 `cronTriggerSettings`、`databaseEventTriggerSettings` 和 `httpRouteTriggerSettings` 并列 — 相同的模式、相同的结构。+<Note>+**与工作流 Code 动作的关系。** 工作流构建器中的内置 **Code** 动作本身就是一个逻辑函数 —— Twenty 会为每个 Code 步骤创建一个逻辑函数,并在行内展示其编辑器。 `workflowActionTriggerSettings` 是将一次性行内代码转换为**可复用**动作的方式:在你的应用中定义一次该函数,它就可以在任意工作流中被选择,而不需要在每个 Code 步骤中复制粘贴。 请参阅用户指南中的[Code 动作](/l/zh/user-guide/workflows/capabilities/workflow-actions#code)以了解终端用户视图。+</Note>+```ts src/logic-functions/enrich-company.logic-function.tsimport { defineLogicFunction } from 'twenty-sdk/define';import { CoreApiClient } from 'twenty-client-sdk/core';@@ -497,6 +501,77 @@ export default defineLogicFunction({});```+##### 完整的工作流动作示例++`workflowActionTriggerSettings` 接受四个字段:++| 字段 | 目的 |+| -------------- | --------------------------------------------------------------------------- |+| `label` | 在工作流构建器的步骤选择器中为该动作显示的名称。 默认为函数的 `name`。 |+| `icon` | 在该动作旁边显示的图标(一个 `tabler-icons` 名称,例如 `IconBuilding`)。 |+| `inputSchema` | Twenty 提供的功能丰富的 `InputSchema` —— 构建器会将其渲染为可配置字段(带变量选择器)。 可选;若省略,则会从处理函数中推断。 |+| `outputSchema` | 声明处理函数返回的数据结构,这样**后续步骤就可以映射到它的输出字段**。 可选;如果不提供,输出会作为单个不透明值暴露。 |++把上述内容组合在一起 —— 将一个函数暴露为工作流动作,并声明输出,以便后续步骤可以引用 `taskId`:++```ts src/logic-functions/enrich-company.logic-function.ts+import { defineLogicFunction } from 'twenty-sdk/define';+import { jsonSchemaToInputSchema, type InputJsonSchema } from 'twenty-sdk/logic-function';+import { CoreApiClient } from 'twenty-client-sdk/core';++const inputSchema: InputJsonSchema = {+ type: 'object',+ properties: {+ companyName: { type: 'string', label: 'Company name' },+ domain: { type: 'string', label: 'Domain' },+ },+ required: ['companyName'],+};++const handler = async (params: { companyName: string; domain?: string }) => {+ const client = new CoreApiClient();++ const result = await client.mutation({+ createTask: {+ __args: {+ data: {+ title: `Enrich data for ${params.companyName}`,+ body: `Domain: ${params.domain ?? 'unknown'}`,+ },+ },+ id: true,+ },+ });++ // The keys returned here should match the `outputSchema` properties below.+ return { taskId: result.createTask.id, enriched: true };+};++export default defineLogicFunction({+ universalIdentifier: 'f47ac10b-58cc-4372-a567-0e02b2c3d479',+ name: 'enrich-company',+ description: 'Enrich a company record with external data',+ timeoutSeconds: 10,+ handler,+ workflowActionTriggerSettings: {+ label: 'Enrich Company',+ icon: 'IconBuilding',+ inputSchema: jsonSchemaToInputSchema(inputSchema),+ outputSchema: [+ {+ type: 'object',+ properties: {+ taskId: { type: 'string' },+ enriched: { type: 'boolean' },+ },+ },+ ],+ },+});+```++应用安装完成后,**Enrich Company** 会出现在工作流构建器的动作选择器中。 构建器会将 `companyName` 和 `domain` 渲染为输入字段(每个字段都可以从前面步骤中获取值),而下游步骤可以引用该步骤的 `taskId` 和 `enriched` 输出。+<Note>**写一个好的 `description`。** AI 智能体会依赖该函数的 `description` 字段来决定何时使用该工具。 明确说明该工具的作用以及应在何时调用。</Note>diff --git a/packages/twenty-docs/l/zh/user-guide/workflows/capabilities/use-iterator.mdx b/packages/twenty-docs/l/zh/user-guide/workflows/capabilities/use-iterator.mdxindex 1ecd4a43559..00a52ccf5b1 100644--- a/packages/twenty-docs/l/zh/user-guide/workflows/capabilities/use-iterator.mdx+++ b/packages/twenty-docs/l/zh/user-guide/workflows/capabilities/use-iterator.mdx@@ -23,6 +23,12 @@ description: 遍历记录数组,对每个项执行操作。3. 移动到下一个元素4. 重复,直到所有元素处理完毕+### 选择要循环的数组++大多数数组来源(Search Records、Webhook 数组字段、Bulk manual trigger)都可以直接在变量选择器中选择。++当 **Code** 或 **Logic Function** 步骤返回一个*顶级数组*时,其输出会在变量选择器中显示为带索引的条目(`0`、`1`、`2`,…)。 若要对整个数组进行循环,请为该步骤选择 **Whole list** 选项 — Iterator 会自动从列表中推断每个项目的结构。+## 基本设置### 示例:向搜索结果中的所有人发送电子邮件@@ -77,6 +83,8 @@ description: 遍历记录数组,对每个项执行操作。| `{{iterator.currentItem.company.name}}` | 关联的公司名称 || `{{iterator.index}}` | 在数组中的当前位置(从 0 开始) |+在变量选择器中,你可以深入当前项目的特定字段,或者选择 **Use the whole item** 来引用整个当前项目(`{{iterator.currentItem}}`)。 在你希望将完整记录直接传入下游步骤,而不是逐个字段重新构建时,选择整个项目会非常方便。+## 常见模式### 更新多条记录diff --git a/packages/twenty-docs/l/zh/user-guide/workflows/capabilities/workflow-actions.mdx b/packages/twenty-docs/l/zh/user-guide/workflows/capabilities/workflow-actions.mdxindex 6a513fbd003..4f3f2fba1e8 100644--- a/packages/twenty-docs/l/zh/user-guide/workflows/capabilities/workflow-actions.mdx+++ b/packages/twenty-docs/l/zh/user-guide/workflows/capabilities/workflow-actions.mdx@@ -112,7 +112,7 @@ import { VimeoEmbed } from '/snippets/vimeo-embed.mdx';**配置**:-* 从前一步中选择记录数组(例如,来自“搜索记录”的结果、来自具有批量可用性的手动触发、来自代码节点)+* 从前一步中选择记录数组(例如,来自“搜索记录”的结果、来自具有批量可用性的手动触发、来自代码节点)。 当 Code 或逻辑函数步骤返回顶级数组时,选择其 **Whole list** 选项以遍历整个输出。* 定义要对循环中每个记录执行的动作.<Note>@@ -120,7 +120,7 @@ import { VimeoEmbed } from '/snippets/vimeo-embed.mdx';- 在迭代器中使用分支时,确保每个分支的最后一步连接回迭代器以闭合循环。</Note>-* 访问 `Current Item` 字段:要使用当前正在处理的记录中的字段,点击 **Iterator** 步骤,然后选择 **Current item**。 将显示该记录可用字段的列表,并可选择用于后续操作。+* 访问 `Current Item` 字段:要使用当前正在处理的记录中的字段,点击 **Iterator** 步骤,然后选择 **Current item**。 将显示该记录可用字段的列表,并可选择用于后续操作。 你也可以选择 **Use the whole item**,将当前整个条目传递到下游步骤。<VimeoEmbed videoId="1146577247" title="视频演示" />@@ -245,6 +245,8 @@ import { VimeoEmbed } from '/snippets/vimeo-embed.mdx';在工作流中运行自定义 JavaScript。+在幕后,每个 Code 操作都由其自己的 **逻辑函数** 支持——一个在 Twenty 平台上运行的服务器端 TypeScript 函数。 当你添加 Code 操作时,Twenty 会为该步骤创建一个专用的逻辑函数,并内联显示其编辑器,因此你编写的代码与工作流共存。+**配置**:* 访问先前步骤中的变量. 你可以动态编辑变量名称。@@ -267,6 +269,25 @@ import { VimeoEmbed } from '/snippets/vimeo-embed.mdx';点击代码编辑器右上角的方形图标以全屏显示——这很有用,因为默认编辑器宽度有限。</Tip>+#### 在多个工作流中复用逻辑函数++内联 Code 操作用于一次性逻辑非常合适,但其中的代码仅属于该单个步骤。 当你希望在多个工作流之间共享相同逻辑,或在应用中将其维护为有版本控制的源码时,应定义一个**可复用逻辑函数**,而不是在每个 Code 操作中复制粘贴代码。++逻辑函数在应用中定义一次(使用 SDK 的 `defineLogicFunction`),并通过添加 `workflowActionTriggerSettings` 暴露给工作流构建器。 安装应用后,该函数会作为独立操作出现在工作流构建器中,与内置操作并列。 选择它会渲染你声明的输入字段(带有变量选择器,与其他操作相同),并运行你的共享代码 —— 无需内联 JavaScript。++| | Code 操作 | 可复用逻辑函数 |+| ---------- | ---------------- | ------------------- |+| **代码所在位置** | 内联编辑器,绑定到单个工作流步骤 | 在应用中定义,在源码管理中进行版本控制 |+| **复用** | 按步骤复制粘贴 | 可作为操作添加到任意工作流中 |+| **输入** | 在编辑器中接入的变量 | 根据你声明的输入模式渲染出的字段 |+| **最适合** | 快速、特定于工作流的逻辑 | 在多个工作流中复用的共享逻辑 |++二者运行在同一逻辑函数运行时上,因此你在内联完成原型的 Code 操作,之后可以以最小改动升级为可复用逻辑函数。++<Tip>+有关为开发者提供的定义逻辑函数并将其暴露给工作流构建器的参考文档,请参阅 [Logic Functions](/l/zh/developers/extend/apps/logic/logic-functions) —— 尤其是 **Exposing a function as an AI tool or workflow action** 部分以及 `workflowActionTriggerSettings`。+</Tip>+### HTTP请求作为工作流的一部分,向外部API发送请求。diff --git a/packages/twenty-docs/l/zh/user-guide/workflows/how-tos/advanced-configurations/handle-arrays-in-code-actions.mdx b/packages/twenty-docs/l/zh/user-guide/workflows/how-tos/advanced-configurations/handle-arrays-in-code-actions.mdxindex 2159f4e95d0..cdef58d7ce7 100644--- a/packages/twenty-docs/l/zh/user-guide/workflows/how-tos/advanced-configurations/handle-arrays-in-code-actions.mdx+++ b/packages/twenty-docs/l/zh/user-guide/workflows/how-tos/advanced-configurations/handle-arrays-in-code-actions.mdx@@ -73,9 +73,9 @@ export const main = async (params: {代码节点返回结构化对象而不是数组。 在随后的步骤中,您现在可以从变量选择器中选择单个字段,例如`answer.firstname` 和 `answer.name` 。-<Note>-我们正在积极努力,在未来的更新中使阵列处理更加容易。-</Note>+<Tip>+**想要遍历数组而不是提取字段?** 当一个 Code 或 Logic Function 步骤返回顶层数组时,你可以将其直接传入 [Iterator](/l/zh/user-guide/workflows/capabilities/use-iterator):在 Iterator 的输入中选择该步骤的 **Whole list** 选项,然后在循环内部使用 `{{iterator.currentItem}}` 引用每个元素。 在那种情况下,你不需要将数组重构为对象。+</Tip><Tip>点击代码编辑器右上角的方形图标在全屏显示它——因为默认编辑器宽度是有限的,所以它是有用的。