Skip to content

The open alternative to Salesforce, designed for AI.

i18n - docs translations (#24711)

github-actions[bot]e6ecef852dec
diff --git a/packages/twenty-docs/l/ar/developers/extend/apps/layout/page-layouts.mdx b/packages/twenty-docs/l/ar/developers/extend/apps/layout/page-layouts.mdx
index 9f29733bf1d..712e918dce1 100644
--- a/packages/twenty-docs/l/ar/developers/extend/apps/layout/page-layouts.mdx
+++ b/packages/twenty-docs/l/ar/developers/extend/apps/layout/page-layouts.mdx
@@ -56,6 +56,7 @@ export default definePageLayout({
* يُعرّف كل `tab` قسمًا من الصفحة مع `title` و`position` و`layoutMode`: `VERTICAL_LIST` لصفحات السجلات والصفحات المستقلة، و`GRID` للوحات المعلومات. في علامة تبويب من نوع `VERTICAL_LIST`، يعرض عنصر واجهة واحد ممتدًا حتى الحواف ويملك علامة التبويب بالكامل؛ وعند وجود عدة عناصر واجهة، فإنها تتكدس كبطاقات. تعرض علامة تبويب من نوع `GRID` دائمًا عناصر الواجهة كبطاقات على شبكة من 12 عمودًا مهما كان عددها، لذا اختر `VERTICAL_LIST` عندما تريد لعنصر واجهة واحد أن يملأ الصفحة.
* عيِّن `layoutMode` بشكل صريح. إغفاله يمنحك `VERTICAL_LIST` على `STANDALONE_PAGE` و`GRID` في كل مكان آخر، وهو أمر نادرًا ما تريده في صفحة سجل.
* يمكن لكل `widget` داخل لسان أن يعرض [front component](/l/ar/developers/extend/apps/layout/front-components)، أو قائمة علاقات، أو أنواعًا أخرى من عناصر الواجهة (widgets) المدمجة.
+* يمكن لعنصر واجهة `FRONT_COMPONENT` تعيين `headerCommandMenuItemUniversalIdentifiers` إلى مصفوفة مرتبة من المعرّفات العامة لعناصر قائمة الأوامر من التطبيق نفسه. تظهر هذه الإجراءات كأزرار أيقونات في رأس بطاقة عنصر الواجهة وتحافظ على فحوصات الإتاحة والأذونات على مستوى الأمر. يجب أن تكون المعرّفات فريدة ويجب أن تُحل عند تثبيت التطبيق.
* `position` على الألسنة يتحكّم في ترتيبها. استخدم قيمًا أعلى (مثل 50) لوضع الألسنة المخصّصة بعد الألسنة المدمجة.
### عناصر واجهة الحقول
@@ -136,8 +137,10 @@ export default definePageLayoutTab({
كل إدخال تخطيط يوفّر أيضًا `tabs` الخاصة به و`widgets` التابعة لها، بحيث يمكنك الرجوع إلى أي مستوى:
```ts
- STANDARD_PAGE_LAYOUT_UNIVERSAL_IDENTIFIERS.taskRecordPage.tabs.home.universalIdentifier
- STANDARD_PAGE_LAYOUT_UNIVERSAL_IDENTIFIERS.taskRecordPage.tabs.home.widgets.fields.universalIdentifier
+ STANDARD_PAGE_LAYOUT_UNIVERSAL_IDENTIFIERS.taskRecordPage.tabs.home
+ .universalIdentifier;
+ STANDARD_PAGE_LAYOUT_UNIVERSAL_IDENTIFIERS.taskRecordPage.tabs.home.widgets
+ .fields.universalIdentifier;
```
يتوفر أيضًا اسم قصير `STANDARD_PAGE_LAYOUT`:
diff --git a/packages/twenty-docs/l/ar/developers/extend/apps/logic/background-jobs.mdx b/packages/twenty-docs/l/ar/developers/extend/apps/logic/background-jobs.mdx
index 5eb1de8a25e..8571380733f 100644
--- a/packages/twenty-docs/l/ar/developers/extend/apps/logic/background-jobs.mdx
+++ b/packages/twenty-docs/l/ar/developers/extend/apps/logic/background-jobs.mdx
@@ -6,45 +6,51 @@ icon: layer-group
تشغيل الدالة المنطقية محدّد بحده الأقصى `timeoutSeconds` ‏(900 ثانية كحد أقصى). أي شيء لا يمكنه أن ينتهي ضمن تلك المهلة الزمنية — مثل إعادة المزامنة الكاملة، أو التوزيع على مستوى كل سجل، أو واجهة برمجة تطبيقات لطرف ثالث تفرض حدودًا على المعدل — يجب تقسيمه إلى عمليات تشغيل أصغر.
-تقوم `enqueueJob` بذلك بالضبط: فهي تطلب من عمّال Twenty تشغيل واحدة من دوال المنطق في تطبيقك لاحقًا، في عملية مستقلة، وبمهلة زمنية خاصة بها. يعود المستدعي فورًا.
+يقوم `enqueueJobs` بذلك بالضبط: فهو يطلب من عمّال Twenty تشغيل إحدى دوال منطق تطبيقك لاحقًا، مرة واحدة لكل حمولة، بحيث يتم كل تشغيل في عملية مستقلة وبمهلة زمنية خاصة به. يعود المستدعي فورًا.
```text
- ┌─────────────────┐ enqueueJob(...) ┌──────────────┐ ┌────────────────────┐
+ ┌─────────────────┐ enqueueJobs(...) ┌──────────────┐ ┌────────────────────┐
│ Logic function │ ─────────────────▶ │ Job queue │──▶│ Logic function │
│ (returns now) │ │ (workers) │ │ (fresh run/timeout)│
└─────────────────┘ └──────────────┘ └────────────────────┘
```
-## إضافة تشغيل إلى قائمة الانتظار (Enqueue)
+## إضافة عمليات التشغيل إلى قائمة الانتظار
-قم باستيراد `enqueueJob` من `twenty-sdk/logic-function` ووجّهه إلى `universalIdentifier` الخاص بوظيفة المنطق التي تريد تشغيلها.
+استورد `enqueueJobs` من `twenty-sdk/logic-function`، ووجّهه إلى `universalIdentifier` الخاص بدالة المنطق المراد تشغيلها، ومرّر حمولة واحدة لكل تشغيل لإضافتها إلى قائمة الانتظار.
```ts src/logic-functions/sync-all-contacts.ts
-import { enqueueJob } from 'twenty-sdk/logic-function';
+import { enqueueJobs } from 'twenty-sdk/logic-function';
-await enqueueJob({
+await enqueueJobs({
logicFunctionUniversalIdentifier: '9f1c3d7e-51b8-4a29-8f0d-7c4e2a6b1d33',
- payload: { page: 1 },
+ payloads: [{ page: 1 }],
});
```
-تستقبل الدالة الهدف `payload` كوسيط للمعالج الخاص بها، تمامًا مثل أي مشغّل (trigger) آخر. يجب أن تنتمي إلى **نفس التطبيق** مثل الدالة المستدعية — تمت إضافة دالة في تطبيق آخر إلى قائمة الانتظار سيتم رفضها برسالة `Logic function not found`.
+يتلقى كل تشغيل حمولته كوسيط للمعالج، تمامًا مثل أي مشغّل آخر. يجب أن تنتمي الدالة الهدف إلى **نفس التطبيق** الذي تنتمي إليه الدالة المستدعية — يُرفض وضع دالة تطبيق آخر في قائمة الانتظار مع ظهور `Logic function not found`، ولا تتم إضافة أي شيء إلى قائمة الانتظار. تقبل المكالمة الواحدة ما يصل إلى `200` حمولة.
<Note>
-تُرجِع `enqueueJob` فور قبول المهمة، وليس عند تشغيلها. لا تُرجِع ناتج الدالة الهدف — اطلب من الدالة الهدف أن تكتب ما تُنتجه في [مخزن المفاتيح والقيم](/l/ar/developers/extend/apps/logic/key-value-store) أو في سجل مساحة العمل إذا كنت بحاجة إلى قراءته لاحقًا.
+تُرجِع `enqueueJobs` فور قبول المهام، وليس عند تشغيلها. لا تُرجِع نتائج الأهداف — اجعل كل دالة هدف تكتب ما تُنتجه في [مخزن المفاتيح والقيم](/l/ar/developers/extend/apps/logic/key-value-store) أو في سجل مساحة العمل إذا كنت بحاجة إلى قراءته لاحقًا.
+</Note>
+
+<Note>
+تم إهمال المساعد الأقدم `enqueueJob`، الذي يضيف مهمة واحدة إلى قائمة الانتظار لكل استدعاء. استخدم `enqueueJobs` مع قائمة `payloads` ذات عنصر واحد بدلًا من ذلك.
</Note>
## خيارات المهمة
+تنطبق الخيارات على كل عملية تشغيل في الدفعة.
+
| الخيار | الإعداد الافتراضي | النطاق | ماذا يفعل |
| ------------ | ----------------- | ------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `retryLimit` | `0` | `0`–`10` | إجمالي محاولات قائمة الانتظار الإضافية. تقتصر عمليات إعادة المحاولة التي يطلبها التطبيق على `3`. لا تقم بزيادة هذه القيمة إلا للمعالجات الآمنة للتشغيل مرتين. |
-| `delayMs` | `0` | `0`–`604800000` (7 أيام) | انتظر هذه المدة قبل أن يصبح التشغيل مؤهّلًا للتنفيذ. |
+| `delayMs` | `0` | `0`–`604800000` (7 أيام) | انتظر هذه المدة قبل أن تصبح عمليات التشغيل مؤهلة للتنفيذ. |
```ts
-await enqueueJob({
+await enqueueJobs({
logicFunctionUniversalIdentifier: '9f1c3d7e-51b8-4a29-8f0d-7c4e2a6b1d33',
- payload: { page: 1 },
+ payloads: [{ page: 1 }],
retryLimit: 3,
delayMs: 60_000,
});
@@ -96,7 +102,7 @@ export const handler = async (
```ts src/logic-functions/sync-contacts-page.ts
import { defineLogicFunction } from 'twenty-sdk/define';
-import { enqueueJob } from 'twenty-sdk/logic-function';
+import { enqueueJobs } from 'twenty-sdk/logic-function';
const SYNC_CONTACTS_PAGE = '9f1c3d7e-51b8-4a29-8f0d-7c4e2a6b1d33';
@@ -106,9 +112,9 @@ const handler = async (params: { cursor?: string }) => {
await importContacts(contacts);
if (nextCursor) {
- await enqueueJob({
+ await enqueueJobs({
logicFunctionUniversalIdentifier: SYNC_CONTACTS_PAGE,
- payload: { cursor: nextCursor },
+ payloads: [{ cursor: nextCursor }],
delayMs: 2_000,
});
}
@@ -126,20 +132,16 @@ export default defineLogicFunction({
## توزيع متشعّب لكل سجل
-عندما يكون العمل بطبيعته لكل عنصر، أضِف مهمة واحدة لكل عنصر إلى قائمة الانتظار ودع العمال (workers) يعالجونها بالتوازي بدلًا من استخدام حلقة داخلية.
+عندما يكون العمل بطبيعته لكل عنصر، أضِف مهمة واحدة لكل عنصر إلى قائمة الانتظار ضمن استدعاء واحد، ودع العمال يعالجونها بالتوازي بدلًا من استخدام حلقة داخلية.
```ts
const companies = await listCompaniesToEnrich();
-await Promise.all(
- companies.map((company) =>
- enqueueJob({
- logicFunctionUniversalIdentifier: ENRICH_COMPANY,
- payload: { companyId: company.id },
- retryLimit: 2,
- }),
- ),
-);
+await enqueueJobs({
+ logicFunctionUniversalIdentifier: ENRICH_COMPANY,
+ payloads: companies.map((company) => ({ companyId: company.id })),
+ retryLimit: 2,
+});
```
## ممارسات جيدة للعمل طويل الأمد
@@ -150,7 +152,7 @@ await Promise.all(
```ts src/logic-functions/enrich-companies-batch.ts
import { defineLogicFunction } from 'twenty-sdk/define';
-import { enqueueJob, kv } from 'twenty-sdk/logic-function';
+import { enqueueJobs, kv } from 'twenty-sdk/logic-function';
const ENRICH_COMPANIES_BATCH = '3f9d1c02-8a44-4f0e-b1d7-9c2e5a7b4f10';
const CHUNK_SIZE = 50;
@@ -169,9 +171,9 @@ const handler = async (params: { offset?: number }) => {
await kv.set('enrich:progress', { offset: offset + companies.length });
if (companies.length === CHUNK_SIZE) {
- await enqueueJob({
+ await enqueueJobs({
logicFunctionUniversalIdentifier: ENRICH_COMPANIES_BATCH,
- payload: { offset: offset + CHUNK_SIZE },
+ payloads: [{ offset: offset + CHUNK_SIZE }],
});
}
diff --git a/packages/twenty-docs/l/cs/developers/extend/apps/layout/page-layouts.mdx b/packages/twenty-docs/l/cs/developers/extend/apps/layout/page-layouts.mdx
index fed41901422..23e34ad8320 100644
--- a/packages/twenty-docs/l/cs/developers/extend/apps/layout/page-layouts.mdx
+++ b/packages/twenty-docs/l/cs/developers/extend/apps/layout/page-layouts.mdx
@@ -56,6 +56,7 @@ export default definePageLayout({
* Každá `tab` definuje sekci stránky s `title`, `position` a `layoutMode`: `VERTICAL_LIST` pro stránky záznamů a samostatné stránky, `GRID` pro řídicí panely. V `VERTICAL_LIST` záložce se jediný widget vykreslí přes celou šířku a zabere celou záložku; pokud je widgetů více, řadí se pod sebe jako karty. `GRID` záložka vždy rozmístí své widgety jako karty v dvanáctisloupcové mřížce, bez ohledu na jejich počet, takže `VERTICAL_LIST` zvolte tehdy, když chcete, aby jeden widget vyplnil celou stránku.
* Nastavte `layoutMode` explicitně. Pokud jej vynecháte, získáte `VERTICAL_LIST` na `STANDALONE_PAGE` a `GRID` všude jinde, což je na stránce záznamu jen zřídka to, co chcete.
* Každý `widget` uvnitř karty může vykreslit [front component](/l/cs/developers/extend/apps/layout/front-components), seznam relací nebo jiné vestavěné typy widgetů.
+* Widget `FRONT_COMPONENT` může nastavit `headerCommandMenuItemUniversalIdentifiers` na seřazené pole univerzálních identifikátorů položek nabídky příkazů ze stejné aplikace. Tyto akce se v záhlaví karty widgetu zobrazují jako tlačítka s ikonami a zachovávají svou dostupnost na úrovni příkazů i kontroly oprávnění. Identifikátory musí být jedinečné a při instalaci aplikace musí být vyřešitelné.
* `position` na kartách určuje jejich pořadí. Použijte vyšší hodnoty (např. 50) pro umístění vlastních karet za vestavěné.
### Widgety polí
@@ -136,8 +137,10 @@ export default definePageLayoutTab({
Každá položka rozvržení také zpřístupňuje své `tabs` a jejich `widgets`, takže můžete odkazovat na libovolnou úroveň:
```ts
- STANDARD_PAGE_LAYOUT_UNIVERSAL_IDENTIFIERS.taskRecordPage.tabs.home.universalIdentifier
- STANDARD_PAGE_LAYOUT_UNIVERSAL_IDENTIFIERS.taskRecordPage.tabs.home.widgets.fields.universalIdentifier
+ STANDARD_PAGE_LAYOUT_UNIVERSAL_IDENTIFIERS.taskRecordPage.tabs.home
+ .universalIdentifier;
+ STANDARD_PAGE_LAYOUT_UNIVERSAL_IDENTIFIERS.taskRecordPage.tabs.home.widgets
+ .fields.universalIdentifier;
```
K dispozici je také krátký alias `STANDARD_PAGE_LAYOUT`:
diff --git a/packages/twenty-docs/l/cs/developers/extend/apps/logic/background-jobs.mdx b/packages/twenty-docs/l/cs/developers/extend/apps/logic/background-jobs.mdx
index ce18b9575ed..8748cd71d28 100644
--- a/packages/twenty-docs/l/cs/developers/extend/apps/logic/background-jobs.mdx
+++ b/packages/twenty-docs/l/cs/developers/extend/apps/logic/background-jobs.mdx
@@ -6,45 +6,51 @@ icon: layer-group
Běh logické funkce je omezen svým `timeoutSeconds` (maximálně 900 sekund). Cokoli, co se nedokáže dokončit v tomto časovém okně — úplná resynchronizace, fan-out pro jednotlivé záznamy, služba třetí strany, která vás omezuje rychlostí — musí být rozděleno do menších běhů.
-`enqueueJob` dělá přesně to: požádá Twenty workery, aby jednu z logických funkcí vaší aplikace spustili později, ve vlastním procesu a s vlastním časovým limitem. Volající se vrátí okamžitě.
+`enqueueJobs` dělá přesně to: požádá Twenty workery, aby později spustili jednu z logických funkcí vaší aplikace, jednou pro každý payload, přičemž každé spuštění proběhne ve vlastním procesu s vlastním časovým limitem. Volající se vrátí okamžitě.
```text
- ┌─────────────────┐ enqueueJob(...) ┌──────────────┐ ┌────────────────────┐
+ ┌─────────────────┐ enqueueJobs(...) ┌──────────────┐ ┌────────────────────┐
│ Logic function │ ─────────────────▶ │ Job queue │──▶│ Logic function │
│ (returns now) │ │ (workers) │ │ (fresh run/timeout)│
└─────────────────┘ └──────────────┘ └────────────────────┘
```
-## Zařazení spuštění do fronty
+## Zařazování spuštění do fronty
-Importujte `enqueueJob` z `twenty-sdk/logic-function` a nasměrujte ho na `universalIdentifier` logické funkce, kterou chcete spustit.
+Importujte `enqueueJobs` z `twenty-sdk/logic-function`, nasměrujte ho na `universalIdentifier` logické funkce, kterou chcete spustit, a předejte do fronty jeden payload pro každé spuštění.
```ts src/logic-functions/sync-all-contacts.ts
-import { enqueueJob } from 'twenty-sdk/logic-function';
+import { enqueueJobs } from 'twenty-sdk/logic-function';
-await enqueueJob({
+await enqueueJobs({
logicFunctionUniversalIdentifier: '9f1c3d7e-51b8-4a29-8f0d-7c4e2a6b1d33',
- payload: { page: 1 },
+ payloads: [{ page: 1 }],
});
```
-Cílová funkce přijímá `payload` jako argument svého handleru, úplně stejně jako jakýkoli jiný spouštěč. Musí patřit do **stejné aplikace** jako volající – zařazení funkce jiné aplikace je odmítnuto s chybou `Logic function not found`.
+Každé spuštění přijímá svůj payload jako argument handleru, úplně stejně jako jakýkoli jiný spouštěč. Cíl musí patřit do **stejné aplikace** jako volající – zařazení funkce jiné aplikace do fronty je odmítnuto s chybou `Logic function not found` a nic se nezařadí do fronty. Jedno volání přijímá až `200` payloadů.
<Note>
-`enqueueJob` se vrátí, jakmile je úloha přijata, ne až když je dokončena. Nevrací výsledek cíle – nechte cíl zapsat, co vytváří, do [úložiště klíč–hodnota](/l/cs/developers/extend/apps/logic/key-value-store) nebo do záznamu v pracovním prostoru, pokud to potřebujete znovu přečíst.
+`enqueueJobs` se vrátí, jakmile jsou úlohy přijaty, nikoli až po jejich spuštění. Nevrací výsledky cílů — nechte každý cíl zapsat, co vytváří, do [úložiště klíč–hodnota](/l/cs/developers/extend/apps/logic/key-value-store) nebo do záznamu v pracovním prostoru, pokud je potřebujete znovu přečíst.
+</Note>
+
+<Note>
+Starší pomocná funkce `enqueueJob`, která zařazuje do fronty jednu úlohu na volání, je zastaralá. Místo toho použijte `enqueueJobs` se seznamem `payloads` s jedním prvkem.
</Note>
## Možnosti úlohy
+Možnosti se vztahují na každé spuštění v dávce.
+
| Možnost | Výchozí | Rozsah | K čemu slouží |
| ------------ | ------- | ----------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `retryLimit` | `0` | `0`–`10` | Celkový počet dalších pokusů ve frontě. Počet opakování vyžádaných aplikací je omezen na `3`. Zvyšujte tuto hodnotu jen u handlerů, které je bezpečné spustit dvakrát. |
-| `delayMs` | `0` | `0`–`604800000` (7 dní) | Po tuto dobu se čeká, než se spuštění stane způsobilým. |
+| `delayMs` | `0` | `0`–`604800000` (7 dní) | Po tuto dobu se čeká, než se spuštění stanou způsobilými. |
```ts
-await enqueueJob({
+await enqueueJobs({
logicFunctionUniversalIdentifier: '9f1c3d7e-51b8-4a29-8f0d-7c4e2a6b1d33',
- payload: { page: 1 },
+ payloads: [{ page: 1 }],
retryLimit: 3,
delayMs: 60_000,
});
@@ -96,7 +102,7 @@ Klasický tvar je funkce, která do fronty zařazuje *samu sebe* s dalším kurz
```ts src/logic-functions/sync-contacts-page.ts
import { defineLogicFunction } from 'twenty-sdk/define';
-import { enqueueJob } from 'twenty-sdk/logic-function';
+import { enqueueJobs } from 'twenty-sdk/logic-function';
const SYNC_CONTACTS_PAGE = '9f1c3d7e-51b8-4a29-8f0d-7c4e2a6b1d33';
@@ -106,9 +112,9 @@ const handler = async (params: { cursor?: string }) => {
await importContacts(contacts);
if (nextCursor) {
- await enqueueJob({
+ await enqueueJobs({
logicFunctionUniversalIdentifier: SYNC_CONTACTS_PAGE,
- payload: { cursor: nextCursor },
+ payloads: [{ cursor: nextCursor }],
delayMs: 2_000,
});
}
@@ -126,20 +132,16 @@ export default defineLogicFunction({
## Rozvětvení po záznamech
-Když je práce přirozeně po položkách, zařaďte do fronty jednu úlohu na položku a nechte workery zpracovávat je paralelně místo smyčky inline.
+Když je práce přirozeně po položkách, zařaďte do fronty jednu úlohu na položku v jednom volání a nechte workery zpracovávat je paralelně místo smyčky inline.
```ts
const companies = await listCompaniesToEnrich();
-await Promise.all(
- companies.map((company) =>
- enqueueJob({
- logicFunctionUniversalIdentifier: ENRICH_COMPANY,
- payload: { companyId: company.id },
- retryLimit: 2,
- }),
- ),
-);
+await enqueueJobs({
+ logicFunctionUniversalIdentifier: ENRICH_COMPANY,
+ payloads: companies.map((company) => ({ companyId: company.id })),
+ retryLimit: 2,
+});
```
## Doporučené postupy pro dlouhotrvající práci
@@ -150,7 +152,7 @@ Spuštění, které se snaží udělat všechno, je způsob selhání – naraz
```ts src/logic-functions/enrich-companies-batch.ts
import { defineLogicFunction } from 'twenty-sdk/define';
-import { enqueueJob, kv } from 'twenty-sdk/logic-function';
+import { enqueueJobs, kv } from 'twenty-sdk/logic-function';
const ENRICH_COMPANIES_BATCH = '3f9d1c02-8a44-4f0e-b1d7-9c2e5a7b4f10';
const CHUNK_SIZE = 50;
@@ -169,9 +171,9 @@ const handler = async (params: { offset?: number }) => {
await kv.set('enrich:progress', { offset: offset + companies.length });
if (companies.length === CHUNK_SIZE) {
- await enqueueJob({
+ await enqueueJobs({
logicFunctionUniversalIdentifier: ENRICH_COMPANIES_BATCH,
- payload: { offset: offset + CHUNK_SIZE },
+ payloads: [{ offset: offset + CHUNK_SIZE }],
});
}
diff --git a/packages/twenty-docs/l/de/developers/extend/apps/layout/page-layouts.mdx b/packages/twenty-docs/l/de/developers/extend/apps/layout/page-layouts.mdx
index 0b13f37189d..4ce922d4d78 100644
--- a/packages/twenty-docs/l/de/developers/extend/apps/layout/page-layouts.mdx
+++ b/packages/twenty-docs/l/de/developers/extend/apps/layout/page-layouts.mdx
@@ -56,6 +56,7 @@ export default definePageLayout({
* Jeder `tab` definiert einen Abschnitt der Seite mit `title`, `position` und `layoutMode`: `VERTICAL_LIST` für Datensatzseiten und eigenständige Seiten, `GRID` für Dashboards. In einem `VERTICAL_LIST`-Tab rendert ein einzelnes Widget in voller Breite und belegt den gesamten Tab; bei mehreren Widgets werden diese als Karten gestapelt. Ein `GRID`-Tab ordnet seine Widgets immer als Karten in einem 12-spaltigen Raster an, unabhängig von ihrer Anzahl. Wähle daher `VERTICAL_LIST`, wenn du möchtest, dass ein Widget die gesamte Seite ausfüllt.
* Setze `layoutMode` explizit. Wenn du es weglässt, erhältst du `VERTICAL_LIST` auf einer `STANDALONE_PAGE` und `GRID` überall sonst, was auf einer Datensatzseite selten gewünscht ist.
* Jedes `widget` innerhalb eines Tabs kann eine [Frontend-Komponente](/l/de/developers/extend/apps/layout/front-components), eine Relationenliste oder andere eingebaute Widget-Typen rendern.
+* Ein `FRONT_COMPONENT`-Widget kann `headerCommandMenuItemUniversalIdentifiers` auf ein geordnetes Array universeller Kennungen von Befehlsmenüelementen aus derselben App festlegen. Diese Aktionen werden als Symbolschaltflächen im Kopf der Widget-Karte angezeigt und behalten ihre Verfügbarkeits- und Berechtigungsprüfungen auf Befehlsebene bei. Kennungen müssen eindeutig sein und bei installierter App aufgelöst werden können.
* `position` auf Tabs steuert deren Reihenfolge. Verwenden Sie höhere Werte (z. B. 50), um benutzerdefinierte Tabs hinter den integrierten zu platzieren.
### Feld-Widgets
@@ -136,8 +137,10 @@ export default definePageLayoutTab({
Jeder Layout-Eintrag stellt außerdem seine `tabs` und deren `widgets` zur Verfügung, sodass Sie auf jede Ebene verweisen können:
```ts
- STANDARD_PAGE_LAYOUT_UNIVERSAL_IDENTIFIERS.taskRecordPage.tabs.home.universalIdentifier
- STANDARD_PAGE_LAYOUT_UNIVERSAL_IDENTIFIERS.taskRecordPage.tabs.home.widgets.fields.universalIdentifier
+ STANDARD_PAGE_LAYOUT_UNIVERSAL_IDENTIFIERS.taskRecordPage.tabs.home
+ .universalIdentifier;
+ STANDARD_PAGE_LAYOUT_UNIVERSAL_IDENTIFIERS.taskRecordPage.tabs.home.widgets
+ .fields.universalIdentifier;
```
Eine kurze Alias-Variable `STANDARD_PAGE_LAYOUT` ist ebenfalls verfügbar:
diff --git a/packages/twenty-docs/l/de/developers/extend/apps/logic/background-jobs.mdx b/packages/twenty-docs/l/de/developers/extend/apps/logic/background-jobs.mdx
index f87a1504c72..08ed049f7df 100644
--- a/packages/twenty-docs/l/de/developers/extend/apps/logic/background-jobs.mdx
+++ b/packages/twenty-docs/l/de/developers/extend/apps/logic/background-jobs.mdx
@@ -6,45 +6,51 @@ icon: layer-group
Ein Logikfunktionslauf ist durch seine `timeoutSeconds` begrenzt (maximal 900 Sekunden). Alles, was in diesem Zeitfenster nicht abgeschlossen werden kann – ein vollständiger Re-Sync, ein Fan-out pro Datensatz, eine Drittanbieter-API, die dich rate-limitiert – muss in kleinere Läufe aufgeteilt werden.
-`enqueueJob` macht genau das: Es weist die Twenty-Worker an, eine der Logikfunktionen deiner App später, in einem eigenen Prozess, mit eigenem Timeout-Budget auszuführen. Der Aufrufer kehrt sofort zurück.
+`enqueueJobs` macht genau das: Es weist die Twenty-Worker an, eine der Logikfunktionen deiner App später, einmal pro Payload, jeweils in einem eigenen Prozess mit eigenem Timeout-Budget auszuführen. Der Aufrufer kehrt sofort zurück.
```text
- ┌─────────────────┐ enqueueJob(...) ┌──────────────┐ ┌────────────────────┐
+ ┌─────────────────┐ enqueueJobs(...) ┌──────────────┐ ┌────────────────────┐
│ Logic function │ ─────────────────▶ │ Job queue │──▶│ Logic function │
│ (returns now) │ │ (workers) │ │ (fresh run/timeout)│
└─────────────────┘ └──────────────┘ └────────────────────┘
```
-## Einen Lauf in die Warteschlange stellen
+## Läufe in die Warteschlange stellen
-Importiere `enqueueJob` aus `twenty-sdk/logic-function` und gib den `universalIdentifier` der Logikfunktion an, die du ausführen möchtest.
+Importiere `enqueueJobs` aus `twenty-sdk/logic-function`, gib den `universalIdentifier` der auszuführenden Logikfunktion an und übergib zum Einreihen eine Payload pro Lauf.
```ts src/logic-functions/sync-all-contacts.ts
-import { enqueueJob } from 'twenty-sdk/logic-function';
+import { enqueueJobs } from 'twenty-sdk/logic-function';
-await enqueueJob({
+await enqueueJobs({
logicFunctionUniversalIdentifier: '9f1c3d7e-51b8-4a29-8f0d-7c4e2a6b1d33',
- payload: { page: 1 },
+ payloads: [{ page: 1 }],
});
```
-Die Zielfunktion erhält `payload` als Handler-Argument, genau wie jeder andere Trigger. Sie muss zur **gleichen Applikation** gehören wie der Aufrufer — das Einreihen der Funktion einer anderen App wird mit `Logic function not found` abgelehnt.
+Jeder Lauf erhält seine Payload als Handler-Argument, genau wie jeder andere Trigger. Das Ziel muss zur **gleichen Applikation** gehören wie der Aufrufer — das Einreihen der Funktion einer anderen App wird mit `Logic function not found` abgelehnt und nichts wird eingereiht. Ein einzelner Aufruf akzeptiert bis zu `200` Payloads.
<Note>
-`enqueueJob` kehrt zurück, sobald der Job akzeptiert wurde, nicht wenn er ausgeführt wurde. Sie gibt nicht das Ergebnis des Ziels zurück — lasse das Ziel das Ergebnis in den [Key-Value-Speicher](/l/de/developers/extend/apps/logic/key-value-store) oder in einen Workspace-Datensatz schreiben, wenn du es wieder auslesen musst.
+`enqueueJobs` kehrt zurück, sobald die Jobs akzeptiert wurden, nicht erst, wenn sie ausgeführt wurden. Sie gibt nicht die Ergebnisse der Ziele zurück — lasse jedes Ziel das, was es erzeugt, in den [Key-Value-Speicher](/l/de/developers/extend/apps/logic/key-value-store) oder in einen Workspace-Datensatz schreiben, wenn du es wieder auslesen musst.
+</Note>
+
+<Note>
+Der ältere Helper `enqueueJob`, der pro Aufruf einen einzelnen Job einreiht, ist veraltet. Verwende stattdessen `enqueueJobs` mit einer `payloads`-Liste mit einem Element.
</Note>
## Job-Optionen
+Optionen gelten für jeden Lauf im Batch.
+
| Option | Standard | Bereich | Was es tut |
| ------------ | -------- | ------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `retryLimit` | `0` | `0`–`10` | Zusätzliche Warteschlangenversuche insgesamt. Von der Anwendung angeforderte Wiederholungsversuche sind auf `3` begrenzt. Erhöhe diesen Wert nur für Handler, die sicher zweimal ausgeführt werden können. |
-| `delayMs` | `0` | `0`–`604800000` (7 Tage) | So lange warten, bevor der Lauf zur Ausführung ansteht. |
+| `delayMs` | `0` | `0`–`604800000` (7 Tage) | So lange warten, bevor die Läufe zur Ausführung anstehen. |
```ts
-await enqueueJob({
+await enqueueJobs({
logicFunctionUniversalIdentifier: '9f1c3d7e-51b8-4a29-8f0d-7c4e2a6b1d33',
- payload: { page: 1 },
+ payloads: [{ page: 1 }],
retryLimit: 3,
delayMs: 60_000,
});
@@ -96,7 +102,7 @@ Die klassische Form ist eine Funktion, die *sich selbst* mit dem nächsten Curso
```ts src/logic-functions/sync-contacts-page.ts
import { defineLogicFunction } from 'twenty-sdk/define';
-import { enqueueJob } from 'twenty-sdk/logic-function';
+import { enqueueJobs } from 'twenty-sdk/logic-function';
const SYNC_CONTACTS_PAGE = '9f1c3d7e-51b8-4a29-8f0d-7c4e2a6b1d33';
@@ -106,9 +112,9 @@ const handler = async (params: { cursor?: string }) => {
await importContacts(contacts);
if (nextCursor) {
- await enqueueJob({
+ await enqueueJobs({
logicFunctionUniversalIdentifier: SYNC_CONTACTS_PAGE,
- payload: { cursor: nextCursor },
+ payloads: [{ cursor: nextCursor }],
delayMs: 2_000,
});
}
@@ -126,20 +132,16 @@ export default defineLogicFunction({
## Aufteilung pro Datensatz
-Wenn die Arbeit natürlich pro Element anfällt, reihe einen Job pro Element ein und lasse die Worker sie parallel verarbeiten, anstatt inline zu iterieren.
+Wenn die Arbeit natürlich pro Element anfällt, reihe in einem einzigen Aufruf einen Job pro Element ein und lasse die Worker sie parallel verarbeiten, anstatt inline zu iterieren.
```ts
const companies = await listCompaniesToEnrich();
-await Promise.all(
- companies.map((company) =>
- enqueueJob({
- logicFunctionUniversalIdentifier: ENRICH_COMPANY,
- payload: { companyId: company.id },
- retryLimit: 2,
- }),
- ),
-);
+await enqueueJobs({
+ logicFunctionUniversalIdentifier: ENRICH_COMPANY,
+ payloads: companies.map((company) => ({ companyId: company.id })),
+ retryLimit: 2,
+});
```
## Bewährte Vorgehensweisen für langlaufende Arbeit
@@ -150,7 +152,7 @@ Ein Lauf, der versucht, alles zu erledigen, ist der Fehlerfall — er erreicht d
```ts src/logic-functions/enrich-companies-batch.ts
import { defineLogicFunction } from 'twenty-sdk/define';
-import { enqueueJob, kv } from 'twenty-sdk/logic-function';
+import { enqueueJobs, kv } from 'twenty-sdk/logic-function';
const ENRICH_COMPANIES_BATCH = '3f9d1c02-8a44-4f0e-b1d7-9c2e5a7b4f10';
const CHUNK_SIZE = 50;
@@ -169,9 +171,9 @@ const handler = async (params: { offset?: number }) => {
await kv.set('enrich:progress', { offset: offset + companies.length });
if (companies.length === CHUNK_SIZE) {
- await enqueueJob({
+ await enqueueJobs({
logicFunctionUniversalIdentifier: ENRICH_COMPANIES_BATCH,
- payload: { offset: offset + CHUNK_SIZE },
+ payloads: [{ offset: offset + CHUNK_SIZE }],
});
}
diff --git a/packages/twenty-docs/l/es/developers/extend/apps/layout/page-layouts.mdx b/packages/twenty-docs/l/es/developers/extend/apps/layout/page-layouts.mdx
index a1a32c62637..3914f02b94d 100644
--- a/packages/twenty-docs/l/es/developers/extend/apps/layout/page-layouts.mdx
+++ b/packages/twenty-docs/l/es/developers/extend/apps/layout/page-layouts.mdx
@@ -56,6 +56,7 @@ export default definePageLayout({
* Cada `tab` define una sección de la página con un `title`, `position` y `layoutMode`: `VERTICAL_LIST` para páginas de registros y páginas independientes, `GRID` para paneles. En una pestaña `VERTICAL_LIST`, un solo widget se muestra a todo lo ancho y ocupa toda la pestaña; con varios widgets, se apilan como tarjetas. Una pestaña `GRID` siempre distribuye sus widgets como tarjetas en una cuadrícula de 12 columnas, sea cual sea su número, así que elige `VERTICAL_LIST` cuando quieras que un widget llene la página.
* Establece `layoutMode` explícitamente. Omitirlo te da `VERTICAL_LIST` en una `STANDALONE_PAGE` y `GRID` en todos los demás casos, lo cual rara vez es lo que quieres en una página de registro.
* Cada `widget` dentro de una pestaña puede renderizar un [componente de frontend](/l/es/developers/extend/apps/layout/front-components), una lista de relaciones u otros tipos de widget integrados.
+* Un widget `FRONT_COMPONENT` puede establecer `headerCommandMenuItemUniversalIdentifiers` en una matriz ordenada de identificadores universales de elementos de menú de comandos de la misma aplicación. Estas acciones aparecen como botones de icono en el encabezado de la tarjeta del widget y conservan sus comprobaciones de disponibilidad y permisos a nivel de comando. Los identificadores deben ser únicos y deben resolverse cuando se instala la aplicación.
* `position` en las pestañas controla su orden. Usa valores más altos (p. ej., 50) para colocar pestañas personalizadas después de las integradas.
### Widgets de campos
@@ -136,8 +137,10 @@ export default definePageLayoutTab({
Cada entrada de diseño también expone sus `tabs` y sus `widgets`, para que puedas hacer referencia a cualquier nivel:
```ts
- STANDARD_PAGE_LAYOUT_UNIVERSAL_IDENTIFIERS.taskRecordPage.tabs.home.universalIdentifier
- STANDARD_PAGE_LAYOUT_UNIVERSAL_IDENTIFIERS.taskRecordPage.tabs.home.widgets.fields.universalIdentifier
+ STANDARD_PAGE_LAYOUT_UNIVERSAL_IDENTIFIERS.taskRecordPage.tabs.home
+ .universalIdentifier;
+ STANDARD_PAGE_LAYOUT_UNIVERSAL_IDENTIFIERS.taskRecordPage.tabs.home.widgets
+ .fields.universalIdentifier;
```
También hay disponible un alias corto `STANDARD_PAGE_LAYOUT`:
diff --git a/packages/twenty-docs/l/es/developers/extend/apps/logic/background-jobs.mdx b/packages/twenty-docs/l/es/developers/extend/apps/logic/background-jobs.mdx
index ed30b68e0f2..30070e720ba 100644
--- a/packages/twenty-docs/l/es/developers/extend/apps/logic/background-jobs.mdx
+++ b/packages/twenty-docs/l/es/developers/extend/apps/logic/background-jobs.mdx
@@ -6,45 +6,51 @@ icon: layer-group
La ejecución de una función lógica está limitada por su `timeoutSeconds` (900 segundos como máximo). Cualquier cosa que no pueda terminar en esa ventana — una resincronización completa, una distribución por registro, una API de terceros que impone límites de tasa — debe dividirse en ejecuciones más pequeñas.
-`enqueueJob` hace exactamente eso: solicita a los workers de Twenty que ejecuten más tarde una de las funciones lógicas de su aplicación, en su propio proceso, con su propio presupuesto de tiempo de espera. La llamada devuelve de inmediato.
+`enqueueJobs` hace exactamente eso: solicita a los workers de Twenty que ejecuten más tarde una de las funciones lógicas de tu aplicación, una vez por carga útil, cada ejecución en su propio proceso con su propio presupuesto de tiempo de espera. La llamada devuelve de inmediato.
```text
- ┌─────────────────┐ enqueueJob(...) ┌──────────────┐ ┌────────────────────┐
+ ┌─────────────────┐ enqueueJobs(...) ┌──────────────┐ ┌────────────────────┐
│ Logic function │ ─────────────────▶ │ Job queue │──▶│ Logic function │
│ (returns now) │ │ (workers) │ │ (fresh run/timeout)│
└─────────────────┘ └──────────────┘ └────────────────────┘
```
-## Poner en cola una ejecución
+## Poner en cola ejecuciones
-Importa `enqueueJob` desde `twenty-sdk/logic-function` y apúntalo al `universalIdentifier` de la función lógica que quieres ejecutar.
+Importa `enqueueJobs` desde `twenty-sdk/logic-function`, apúntalo al `universalIdentifier` de la función lógica que se ejecutará y pasa una carga útil por ejecución para poner en cola.
```ts src/logic-functions/sync-all-contacts.ts
-import { enqueueJob } from 'twenty-sdk/logic-function';
+import { enqueueJobs } from 'twenty-sdk/logic-function';
-await enqueueJob({
+await enqueueJobs({
logicFunctionUniversalIdentifier: '9f1c3d7e-51b8-4a29-8f0d-7c4e2a6b1d33',
- payload: { page: 1 },
+ payloads: [{ page: 1 }],
});
```
-La función de destino recibe `payload` como su argumento de manejador, exactamente igual que cualquier otro disparador. Debe pertenecer a la **misma aplicación** que realiza la llamada: poner en cola la función de otra aplicación se rechaza con `Logic function not found`.
+Cada ejecución recibe su carga útil como argumento del manejador, exactamente igual que cualquier otro disparador. El destino debe pertenecer a la **misma aplicación** que quien realiza la llamada; poner en cola la función de otra aplicación se rechaza con `Logic function not found` y no se pone nada en cola. Una sola llamada acepta hasta `200` cargas útiles.
<Note>
-`enqueueJob` devuelve tan pronto como se acepta el trabajo, no cuando ya se ha ejecutado. No devuelve el resultado del destino: haz que el destino escriba lo que produce en el [almacenamiento de pares clave-valor](/l/es/developers/extend/apps/logic/key-value-store) o en un registro del espacio de trabajo si necesitas leerlo después.
+`enqueueJobs` devuelve tan pronto como se aceptan los trabajos, no cuando se han ejecutado. No devuelve los resultados de los destinos: haz que cada destino escriba lo que produce en el [almacenamiento de pares clave-valor](/l/es/developers/extend/apps/logic/key-value-store) o en un registro del espacio de trabajo si necesitas leerlo después.
+</Note>
+
+<Note>
+El auxiliar `enqueueJob` más antiguo, que pone en cola un único trabajo por llamada, ha quedado obsoleto. Usa `enqueueJobs` con una lista `payloads` de un elemento en su lugar.
</Note>
## Opciones del trabajo
+Las opciones se aplican a todas las ejecuciones del lote.
+
| Opción | Predeterminado | Rango | Qué hace |
| ------------ | -------------- | ------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `retryLimit` | `0` | `0`–`10` | Intentos adicionales totales en la cola. Los reintentos solicitados por la aplicación tienen un límite de `3`. Solo incrementa este valor para manejadores que se puedan ejecutar dos veces de forma segura. |
-| `delayMs` | `0` | `0`–`604800000` (7 días) | Espera este tiempo antes de que la ejecución sea elegible. |
+| `delayMs` | `0` | `0`–`604800000` (7 días) | Espera este tiempo antes de que las ejecuciones sean elegibles. |
```ts
-await enqueueJob({
+await enqueueJobs({
logicFunctionUniversalIdentifier: '9f1c3d7e-51b8-4a29-8f0d-7c4e2a6b1d33',
- payload: { page: 1 },
+ payloads: [{ page: 1 }],
retryLimit: 3,
delayMs: 60_000,
});
@@ -96,7 +102,7 @@ La forma clásica es una función que se pone en cola *a sí misma* con el curso
```ts src/logic-functions/sync-contacts-page.ts
import { defineLogicFunction } from 'twenty-sdk/define';
-import { enqueueJob } from 'twenty-sdk/logic-function';
+import { enqueueJobs } from 'twenty-sdk/logic-function';
const SYNC_CONTACTS_PAGE = '9f1c3d7e-51b8-4a29-8f0d-7c4e2a6b1d33';
@@ -106,9 +112,9 @@ const handler = async (params: { cursor?: string }) => {
await importContacts(contacts);
if (nextCursor) {
- await enqueueJob({
+ await enqueueJobs({
logicFunctionUniversalIdentifier: SYNC_CONTACTS_PAGE,
- payload: { cursor: nextCursor },
+ payloads: [{ cursor: nextCursor }],
delayMs: 2_000,
});
}
@@ -126,20 +132,16 @@ export default defineLogicFunction({
## Dividir por registro
-Cuando el trabajo es de forma natural por elemento, pon en cola un trabajo por elemento y deja que los workers los procesen en paralelo en lugar de iterar en línea.
+Cuando el trabajo es de forma natural por elemento, pon en cola un trabajo por elemento en una sola llamada y deja que los workers los procesen en paralelo en lugar de iterar en línea.
```ts
const companies = await listCompaniesToEnrich();
-await Promise.all(
- companies.map((company) =>
- enqueueJob({
- logicFunctionUniversalIdentifier: ENRICH_COMPANY,
- payload: { companyId: company.id },
- retryLimit: 2,
- }),
- ),
-);
+await enqueueJobs({
+ logicFunctionUniversalIdentifier: ENRICH_COMPANY,
+ payloads: companies.map((company) => ({ companyId: company.id })),
+ retryLimit: 2,
+});
```
## Buenas prácticas para trabajos de larga duración
@@ -150,7 +152,7 @@ Una ejecución que intenta hacerlo todo es la forma en que falla: alcanza el tie
```ts src/logic-functions/enrich-companies-batch.ts
import { defineLogicFunction } from 'twenty-sdk/define';
-import { enqueueJob, kv } from 'twenty-sdk/logic-function';
+import { enqueueJobs, kv } from 'twenty-sdk/logic-function';
const ENRICH_COMPANIES_BATCH = '3f9d1c02-8a44-4f0e-b1d7-9c2e5a7b4f10';
const CHUNK_SIZE = 50;
@@ -169,9 +171,9 @@ const handler = async (params: { offset?: number }) => {
await kv.set('enrich:progress', { offset: offset + companies.length });
if (companies.length === CHUNK_SIZE) {
- await enqueueJob({
+ await enqueueJobs({
logicFunctionUniversalIdentifier: ENRICH_COMPANIES_BATCH,
- payload: { offset: offset + CHUNK_SIZE },
+ payloads: [{ offset: offset + CHUNK_SIZE }],
});
}
diff --git a/packages/twenty-docs/l/fr/developers/extend/apps/layout/page-layouts.mdx b/packages/twenty-docs/l/fr/developers/extend/apps/layout/page-layouts.mdx
index f63325d6139..459f741d6fc 100644
--- a/packages/twenty-docs/l/fr/developers/extend/apps/layout/page-layouts.mdx
+++ b/packages/twenty-docs/l/fr/developers/extend/apps/layout/page-layouts.mdx
@@ -56,6 +56,7 @@ export default definePageLayout({
* Chaque `tab` définit une section de la page avec un `title`, une `position` et un `layoutMode` : `VERTICAL_LIST` pour les pages d'enregistrement et les pages autonomes, `GRID` pour les tableaux de bord. Dans un onglet `VERTICAL_LIST`, un seul widget est affiché en pleine largeur et occupe tout l'onglet ; avec plusieurs widgets, ils sont empilés sous forme de cartes. Un onglet `GRID` dispose toujours ses widgets sous forme de cartes sur une grille de 12 colonnes, quel que soit leur nombre ; choisissez donc `VERTICAL_LIST` lorsque vous voulez qu'un seul widget remplisse la page.
* Définissez `layoutMode` explicitement. Si vous l’omettez, vous obtenez `VERTICAL_LIST` sur une `STANDALONE_PAGE` et `GRID` partout ailleurs, ce qui est rarement ce que vous voulez sur une page d’enregistrement.
* Chaque `widget` à l'intérieur d'un onglet peut afficher un [front component](/l/fr/developers/extend/apps/layout/front-components), une liste de relations ou d'autres types de widgets intégrés.
+* Un widget `FRONT_COMPONENT` peut définir `headerCommandMenuItemUniversalIdentifiers` sur un tableau ordonné d’identifiants universels d’éléments du menu de commandes provenant de la même app. Ces actions apparaissent sous forme de boutons d’icône dans l’en-tête de la carte du widget et conservent leur disponibilité au niveau de la commande ainsi que leurs vérifications des autorisations. Les identifiants doivent être uniques et doivent pouvoir être résolus lors de l’installation de l’app.
* La `position` des onglets contrôle leur ordre. Utilisez des valeurs plus élevées (p. ex., 50) pour placer les onglets personnalisés après les onglets intégrés.
### Widgets des champs
@@ -136,8 +137,10 @@ export default definePageLayoutTab({
Chaque entrée de mise en page expose également ses `tabs` et leurs `widgets`, afin que vous puissiez faire référence à n’importe quel niveau :
```ts
- STANDARD_PAGE_LAYOUT_UNIVERSAL_IDENTIFIERS.taskRecordPage.tabs.home.universalIdentifier
- STANDARD_PAGE_LAYOUT_UNIVERSAL_IDENTIFIERS.taskRecordPage.tabs.home.widgets.fields.universalIdentifier
+ STANDARD_PAGE_LAYOUT_UNIVERSAL_IDENTIFIERS.taskRecordPage.tabs.home
+ .universalIdentifier;
+ STANDARD_PAGE_LAYOUT_UNIVERSAL_IDENTIFIERS.taskRecordPage.tabs.home.widgets
+ .fields.universalIdentifier;
```
Un alias court `STANDARD_PAGE_LAYOUT` est également disponible :
diff --git a/packages/twenty-docs/l/fr/developers/extend/apps/logic/background-jobs.mdx b/packages/twenty-docs/l/fr/developers/extend/apps/logic/background-jobs.mdx
index b467418513e..f15d033d898 100644
--- a/packages/twenty-docs/l/fr/developers/extend/apps/logic/background-jobs.mdx
+++ b/packages/twenty-docs/l/fr/developers/extend/apps/logic/background-jobs.mdx
@@ -6,45 +6,51 @@ icon: layer-group
Une exécution de fonction logique est limitée par son `timeoutSeconds` (900 secondes maximum). Tout ce qui ne peut pas se terminer dans cette fenêtre — une resynchronisation complète, une diffusion par enregistrement, une API tierce qui vous applique des limitations de débit — doit être découpé en exécutions plus petites.
-`enqueueJob` fait exactement cela : il demande aux workers de Twenty d’exécuter plus tard l’une des fonctions logiques de votre application, dans son propre processus, avec son propre budget de délai d’expiration. La fonction appelante retourne immédiatement.
+`enqueueJobs` fait exactement cela : il demande aux workers de Twenty d’exécuter plus tard l’une des fonctions logiques de votre application, une fois par charge utile, chaque exécution dans son propre processus avec son propre budget de délai d’expiration. La fonction appelante retourne immédiatement.
```text
- ┌─────────────────┐ enqueueJob(...) ┌──────────────┐ ┌────────────────────┐
+ ┌─────────────────┐ enqueueJobs(...) ┌──────────────┐ ┌────────────────────┐
│ Logic function │ ─────────────────▶ │ Job queue │──▶│ Logic function │
│ (returns now) │ │ (workers) │ │ (fresh run/timeout)│
└─────────────────┘ └──────────────┘ └────────────────────┘
```
-## Mettre en file d’attente une exécution
+## Mettre des exécutions en file d’attente
-Importez `enqueueJob` depuis `twenty-sdk/logic-function` et pointez-le vers le `universalIdentifier` de la fonction logique que vous voulez exécuter.
+Importez `enqueueJobs` depuis `twenty-sdk/logic-function`, pointez-le vers le `universalIdentifier` de la fonction logique à exécuter et transmettez une charge utile par exécution pour la mise en file d’attente.
```ts src/logic-functions/sync-all-contacts.ts
-import { enqueueJob } from 'twenty-sdk/logic-function';
+import { enqueueJobs } from 'twenty-sdk/logic-function';
-await enqueueJob({
+await enqueueJobs({
logicFunctionUniversalIdentifier: '9f1c3d7e-51b8-4a29-8f0d-7c4e2a6b1d33',
- payload: { page: 1 },
+ payloads: [{ page: 1 }],
});
```
-La fonction cible reçoit `payload` comme argument de son gestionnaire, exactement comme pour tout autre déclencheur. Elle doit appartenir à la **même application** que l’appelant — la mise en file d’attente de la fonction d’une autre application est rejetée avec `Logic function not found`.
+Chaque exécution reçoit sa charge utile comme argument du gestionnaire, exactement comme pour tout autre déclencheur. La cible doit appartenir à la **même application** que l’appelant — la mise en file d’attente de la fonction d’une autre application est rejetée avec `Logic function not found` et rien n’est mis en file d’attente. Un seul appel accepte jusqu’à `200` charges utiles.
<Note>
-`enqueueJob` renvoie dès que le job est accepté, et non pas lorsqu’il a été exécuté. Il ne renvoie pas le résultat de la cible — faites en sorte que la cible écrive ce qu’elle produit dans le [key-value store](/l/fr/developers/extend/apps/logic/key-value-store) ou dans un enregistrement d’espace de travail si vous devez le lire à nouveau.
+`enqueueJobs` renvoie dès que les jobs sont acceptés, et non pas lorsqu’ils ont été exécutés. Il ne renvoie pas les résultats des cibles — faites en sorte que chaque cible écrive ce qu’elle produit dans le [key-value store](/l/fr/developers/extend/apps/logic/key-value-store) ou dans un enregistrement d’espace de travail si vous devez les lire à nouveau.
+</Note>
+
+<Note>
+L’ancien assistant `enqueueJob`, qui met en file d’attente un seul job par appel, est obsolète. Utilisez plutôt `enqueueJobs` avec une liste `payloads` à un élément.
</Note>
## Options du job
+Les options s’appliquent à chaque exécution du lot.
+
| Option | Par défaut | Plage | Ce que cela fait |
| ------------ | ---------- | ------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `retryLimit` | `0` | `0`–`10` | Nombre total de tentatives supplémentaires dans la file d'attente. Les nouvelles tentatives demandées par l'application sont limitées à `3`. N’augmentez cette valeur que pour les gestionnaires qui peuvent être exécutés deux fois en toute sécurité. |
-| `delayMs` | `0` | `0`–`604800000` (7 jours) | Attendez ce délai avant que l’exécution devienne éligible. |
+| `delayMs` | `0` | `0`–`604800000` (7 jours) | Attendez ce délai avant que les exécutions deviennent éligibles. |
```ts
-await enqueueJob({
+await enqueueJobs({
logicFunctionUniversalIdentifier: '9f1c3d7e-51b8-4a29-8f0d-7c4e2a6b1d33',
- payload: { page: 1 },
+ payloads: [{ page: 1 }],
retryLimit: 3,
delayMs: 60_000,
});
@@ -96,7 +102,7 @@ La forme classique est une fonction qui met *elle-même* en file d’attente la
```ts src/logic-functions/sync-contacts-page.ts
import { defineLogicFunction } from 'twenty-sdk/define';
-import { enqueueJob } from 'twenty-sdk/logic-function';
+import { enqueueJobs } from 'twenty-sdk/logic-function';
const SYNC_CONTACTS_PAGE = '9f1c3d7e-51b8-4a29-8f0d-7c4e2a6b1d33';
@@ -106,9 +112,9 @@ const handler = async (params: { cursor?: string }) => {
await importContacts(contacts);
if (nextCursor) {
- await enqueueJob({
+ await enqueueJobs({
logicFunctionUniversalIdentifier: SYNC_CONTACTS_PAGE,
- payload: { cursor: nextCursor },
+ payloads: [{ cursor: nextCursor }],
delayMs: 2_000,
});
}
@@ -126,20 +132,16 @@ export default defineLogicFunction({
## Répartition par enregistrement
-Quand le travail est naturellement par élément, mettez en file d’attente un job par élément et laissez les workers les traiter en parallèle au lieu de boucler en ligne.
+Quand le travail est naturellement par élément, mettez en file d’attente un job par élément dans un seul appel et laissez les workers les traiter en parallèle au lieu de boucler en ligne.
```ts
const companies = await listCompaniesToEnrich();
-await Promise.all(
- companies.map((company) =>
- enqueueJob({
- logicFunctionUniversalIdentifier: ENRICH_COMPANY,
- payload: { companyId: company.id },
- retryLimit: 2,
- }),
- ),
-);
+await enqueueJobs({
+ logicFunctionUniversalIdentifier: ENRICH_COMPANY,
+ payloads: companies.map((company) => ({ companyId: company.id })),
+ retryLimit: 2,
+});
```
## Bonnes pratiques pour les tâches de longue durée
@@ -150,7 +152,7 @@ Une exécution qui essaie de tout faire est un mode d’échec — elle atteint
```ts src/logic-functions/enrich-companies-batch.ts
import { defineLogicFunction } from 'twenty-sdk/define';
-import { enqueueJob, kv } from 'twenty-sdk/logic-function';
+import { enqueueJobs, kv } from 'twenty-sdk/logic-function';
const ENRICH_COMPANIES_BATCH = '3f9d1c02-8a44-4f0e-b1d7-9c2e5a7b4f10';
const CHUNK_SIZE = 50;
@@ -169,9 +171,9 @@ const handler = async (params: { offset?: number }) => {
await kv.set('enrich:progress', { offset: offset + companies.length });
if (companies.length === CHUNK_SIZE) {
- await enqueueJob({
+ await enqueueJobs({
logicFunctionUniversalIdentifier: ENRICH_COMPANIES_BATCH,
- payload: { offset: offset + CHUNK_SIZE },
+ payloads: [{ offset: offset + CHUNK_SIZE }],
});
}
diff --git a/packages/twenty-docs/l/it/developers/extend/apps/layout/page-layouts.mdx b/packages/twenty-docs/l/it/developers/extend/apps/layout/page-layouts.mdx
index c2a661ca3c5..4e05facbec2 100644
--- a/packages/twenty-docs/l/it/developers/extend/apps/layout/page-layouts.mdx
+++ b/packages/twenty-docs/l/it/developers/extend/apps/layout/page-layouts.mdx
@@ -56,6 +56,7 @@ export default definePageLayout({
* Ogni `tab` definisce una sezione della pagina con `title`, `position` e `layoutMode`: `VERTICAL_LIST` per le pagine dei record e le pagine autonome, `GRID` per le dashboard. In una scheda `VERTICAL_LIST`, un singolo widget viene visualizzato a tutta larghezza e occupa l’intera scheda; con più widget, vengono impilati come card. Una scheda `GRID` dispone sempre i widget come card su una griglia a 12 colonne, qualunque sia il loro numero, quindi scegli `VERTICAL_LIST` quando vuoi che un widget riempia la pagina.
* Imposta esplicitamente `layoutMode`. Ometterlo imposta `VERTICAL_LIST` su una `STANDALONE_PAGE` e `GRID` altrove, il che raramente è ciò che vuoi per la pagina di un record.
* Ogni `widget` all'interno di una scheda può renderizzare un [front component](/l/it/developers/extend/apps/layout/front-components), un elenco di relazioni o altri tipi di widget integrati.
+* Un widget `FRONT_COMPONENT` può impostare `headerCommandMenuItemUniversalIdentifiers` su un array ordinato di identificatori universali degli elementi del menu di comandi della stessa app. Queste azioni vengono visualizzate come pulsanti con icona nell'intestazione della scheda del widget e mantengono la disponibilità a livello di comando e i controlli delle autorizzazioni. Gli identificatori devono essere univoci e devono essere risolti quando l'app viene installata.
* `position` sulle schede controlla il loro ordine. Usa valori più alti (ad es., 50) per posizionare le schede personalizzate dopo quelle integrate.
### Widget dei campi
@@ -136,8 +137,10 @@ export default definePageLayoutTab({
Ogni voce di layout espone anche i propri `tabs` e i relativi `widgets`, così puoi fare riferimento a qualsiasi livello:
```ts
- STANDARD_PAGE_LAYOUT_UNIVERSAL_IDENTIFIERS.taskRecordPage.tabs.home.universalIdentifier
- STANDARD_PAGE_LAYOUT_UNIVERSAL_IDENTIFIERS.taskRecordPage.tabs.home.widgets.fields.universalIdentifier
+ STANDARD_PAGE_LAYOUT_UNIVERSAL_IDENTIFIERS.taskRecordPage.tabs.home
+ .universalIdentifier;
+ STANDARD_PAGE_LAYOUT_UNIVERSAL_IDENTIFIERS.taskRecordPage.tabs.home.widgets
+ .fields.universalIdentifier;
```
È disponibile anche un alias breve `STANDARD_PAGE_LAYOUT`:
diff --git a/packages/twenty-docs/l/it/developers/extend/apps/logic/background-jobs.mdx b/packages/twenty-docs/l/it/developers/extend/apps/logic/background-jobs.mdx
index 884e72ff106..04259ed97ee 100644
--- a/packages/twenty-docs/l/it/developers/extend/apps/logic/background-jobs.mdx
+++ b/packages/twenty-docs/l/it/developers/extend/apps/logic/background-jobs.mdx
@@ -6,45 +6,51 @@ icon: layer-group
L'esecuzione di una logic function è limitata dal suo `timeoutSeconds` (massimo 900 secondi). Qualsiasi attività che non può essere completata in tale intervallo — una risincronizzazione completa, un fan-out per record, un'API di terze parti che applica limitazioni di frequenza — deve essere suddivisa in esecuzioni più piccole.
-`enqueueJob` fa esattamente questo: chiede ai worker di Twenty di eseguire in un secondo momento una delle logic function della tua app, in un proprio processo, con il proprio budget di timeout. Il chiamante restituisce immediatamente.
+`enqueueJobs` fa esattamente questo: chiede ai worker di Twenty di eseguire in un secondo momento una delle logic function della tua app, una volta per payload, ogni esecuzione nel proprio processo con il proprio budget di timeout. Il chiamante restituisce immediatamente.
```text
- ┌─────────────────┐ enqueueJob(...) ┌──────────────┐ ┌────────────────────┐
+ ┌─────────────────┐ enqueueJobs(...) ┌──────────────┐ ┌────────────────────┐
│ Logic function │ ─────────────────▶ │ Job queue │──▶│ Logic function │
│ (returns now) │ │ (workers) │ │ (fresh run/timeout)│
└─────────────────┘ └──────────────┘ └────────────────────┘
```
-## Inserire in coda un'esecuzione
+## Mettere in coda esecuzioni
-Importa `enqueueJob` da `twenty-sdk/logic-function` e puntalo all'`universalIdentifier` della logic function che vuoi eseguire.
+Importa `enqueueJobs` da `twenty-sdk/logic-function`, puntalo all'`universalIdentifier` della logic function da eseguire e passa un payload per ogni esecuzione da mettere in coda.
```ts src/logic-functions/sync-all-contacts.ts
-import { enqueueJob } from 'twenty-sdk/logic-function';
+import { enqueueJobs } from 'twenty-sdk/logic-function';
-await enqueueJob({
+await enqueueJobs({
logicFunctionUniversalIdentifier: '9f1c3d7e-51b8-4a29-8f0d-7c4e2a6b1d33',
- payload: { page: 1 },
+ payloads: [{ page: 1 }],
});
```
-La funzione di destinazione riceve `payload` come argomento del suo handler, esattamente come qualsiasi altro trigger. Deve appartenere alla **stessa applicazione** del chiamante: l'inserimento in coda della funzione di un'altra app viene rifiutato con `Logic function not found`.
+Ogni esecuzione riceve il proprio payload come argomento dell'handler, esattamente come qualsiasi altro trigger. La destinazione deve appartenere alla **stessa applicazione** del chiamante — l'inserimento in coda della funzione di un'altra app viene rifiutato con `Logic function not found` e non viene inserito nulla in coda. Una singola chiamata accetta fino a `200` payload.
<Note>
-`enqueueJob` restituisce non appena il job è stato accettato, non quando è stato eseguito. Non restituisce il risultato della destinazione: fai scrivere alla destinazione ciò che produce nel [key-value store](/l/it/developers/extend/apps/logic/key-value-store) o in un record dello spazio di lavoro se hai bisogno di leggerlo di nuovo.
+`enqueueJobs` restituisce non appena i job sono stati accettati, non quando sono stati eseguiti. Non restituisce i risultati delle destinazioni: fai scrivere a ciascuna destinazione ciò che produce nel [key-value store](/l/it/developers/extend/apps/logic/key-value-store) o in un record dello spazio di lavoro se hai bisogno di leggerlo di nuovo.
+</Note>
+
+<Note>
+Il precedente helper `enqueueJob`, che mette in coda un singolo job per chiamata, è deprecato. Usa invece `enqueueJobs` con un elenco `payloads` di un solo elemento.
</Note>
## Opzioni del job
+Le opzioni si applicano a ogni esecuzione nel batch.
+
| Opzione | Predefinito | Intervallo | Cosa fa |
| ------------ | ----------- | -------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `retryLimit` | `0` | `0`–`10` | Tentativi aggiuntivi complessivi nella coda. I nuovi tentativi richiesti dall'applicazione sono limitati a `3`. Aumenta questo valore solo per gli handler che possono essere eseguiti due volte in sicurezza. |
-| `delayMs` | `0` | `0`–`604800000` (7 giorni) | Attendi questo intervallo prima che l'esecuzione diventi idonea. |
+| `delayMs` | `0` | `0`–`604800000` (7 giorni) | Attendi questo intervallo prima che le esecuzioni diventino idonee. |
```ts
-await enqueueJob({
+await enqueueJobs({
logicFunctionUniversalIdentifier: '9f1c3d7e-51b8-4a29-8f0d-7c4e2a6b1d33',
- payload: { page: 1 },
+ payloads: [{ page: 1 }],
retryLimit: 3,
delayMs: 60_000,
});
@@ -96,7 +102,7 @@ La forma classica è una funzione che mette in coda *se stessa* con il cursore s
```ts src/logic-functions/sync-contacts-page.ts
import { defineLogicFunction } from 'twenty-sdk/define';
-import { enqueueJob } from 'twenty-sdk/logic-function';
+import { enqueueJobs } from 'twenty-sdk/logic-function';
const SYNC_CONTACTS_PAGE = '9f1c3d7e-51b8-4a29-8f0d-7c4e2a6b1d33';
@@ -106,9 +112,9 @@ const handler = async (params: { cursor?: string }) => {
await importContacts(contacts);
if (nextCursor) {
- await enqueueJob({
+ await enqueueJobs({
logicFunctionUniversalIdentifier: SYNC_CONTACTS_PAGE,
- payload: { cursor: nextCursor },
+ payloads: [{ cursor: nextCursor }],
delayMs: 2_000,
});
}
@@ -126,20 +132,16 @@ export default defineLogicFunction({
## Suddivisione per record
-Quando il lavoro è naturalmente per elemento, metti in coda un job per elemento e lascia che i worker li elaborino in parallelo invece di ciclare in linea.
+Quando il lavoro è naturalmente per elemento, metti in coda un job per elemento in una singola chiamata e lascia che i worker li elaborino in parallelo invece di ciclare in linea.
```ts
const companies = await listCompaniesToEnrich();
-await Promise.all(
- companies.map((company) =>
- enqueueJob({
- logicFunctionUniversalIdentifier: ENRICH_COMPANY,
- payload: { companyId: company.id },
- retryLimit: 2,
- }),
- ),
-);
+await enqueueJobs({
+ logicFunctionUniversalIdentifier: ENRICH_COMPANY,
+ payloads: companies.map((company) => ({ companyId: company.id })),
+ retryLimit: 2,
+});
```
## Buone pratiche per il lavoro di lunga durata
@@ -150,7 +152,7 @@ Un'esecuzione che prova a fare tutto è una modalità di errore: raggiunge il ti
```ts src/logic-functions/enrich-companies-batch.ts
import { defineLogicFunction } from 'twenty-sdk/define';
-import { enqueueJob, kv } from 'twenty-sdk/logic-function';
+import { enqueueJobs, kv } from 'twenty-sdk/logic-function';
const ENRICH_COMPANIES_BATCH = '3f9d1c02-8a44-4f0e-b1d7-9c2e5a7b4f10';
const CHUNK_SIZE = 50;
@@ -169,9 +171,9 @@ const handler = async (params: { offset?: number }) => {
await kv.set('enrich:progress', { offset: offset + companies.length });
if (companies.length === CHUNK_SIZE) {
- await enqueueJob({
+ await enqueueJobs({
logicFunctionUniversalIdentifier: ENRICH_COMPANIES_BATCH,
- payload: { offset: offset + CHUNK_SIZE },
+ payloads: [{ offset: offset + CHUNK_SIZE }],
});
}
diff --git a/packages/twenty-docs/l/ja/developers/extend/apps/layout/page-layouts.mdx b/packages/twenty-docs/l/ja/developers/extend/apps/layout/page-layouts.mdx
index 74b8018a98f..d7cf692f02f 100644
--- a/packages/twenty-docs/l/ja/developers/extend/apps/layout/page-layouts.mdx
+++ b/packages/twenty-docs/l/ja/developers/extend/apps/layout/page-layouts.mdx
@@ -56,6 +56,7 @@ export default definePageLayout({
* 各 `tab` は、`title`、`position`、`layoutMode` を持つページのセクションを定義します。レコードページおよびスタンドアロンページには `VERTICAL_LIST`、ダッシュボードには `GRID` を使用します。 `VERTICAL_LIST` タブでは、1 つのウィジェットのみの場合はそのウィジェットがフルブリードでタブ全体に表示され、複数のウィジェットがある場合はカードとして積み重なります。 `GRID` タブでは、ウィジェットの数に関係なく、常に 12 列グリッド上でカードとして配置されます。そのため、1 つのウィジェットにページ全体を使わせたい場合は `VERTICAL_LIST` を選択します。
* `layoutMode` を明示的に設定します。 `layoutMode` を省略すると、`STANDALONE_PAGE` では `VERTICAL_LIST`、それ以外では `GRID` が適用されますが、これはレコードページで望ましい動作であることはほとんどありません。
* タブ内の各 `widget` は、[front component](/l/ja/developers/extend/apps/layout/front-components)、リレーションリスト、その他のビルトインウィジェットタイプをレンダリングできます。
+* `FRONT_COMPONENT` ウィジェットでは、同じアプリのコマンドメニュー項目ユニバーサル識別子を順序付き配列として `headerCommandMenuItemUniversalIdentifiers` に設定できます。 これらのアクションはウィジェットカードヘッダーにアイコンボタンとして表示され、コマンドレベルの可用性チェックと権限チェックが維持されます。 識別子は一意である必要があり、アプリのインストール時に解決される必要があります。
* タブの `position` は表示順を制御します。 組み込みタブの後にカスタムタブを配置するには、より大きな値(例:50)を使用します。
### フィールド ウィジェット
@@ -136,8 +137,10 @@ export default definePageLayoutTab({
各レイアウトエントリは、その `tabs` とその `widgets` も公開しているため、任意の階層を参照できます:
```ts
- STANDARD_PAGE_LAYOUT_UNIVERSAL_IDENTIFIERS.taskRecordPage.tabs.home.universalIdentifier
- STANDARD_PAGE_LAYOUT_UNIVERSAL_IDENTIFIERS.taskRecordPage.tabs.home.widgets.fields.universalIdentifier
+ STANDARD_PAGE_LAYOUT_UNIVERSAL_IDENTIFIERS.taskRecordPage.tabs.home
+ .universalIdentifier;
+ STANDARD_PAGE_LAYOUT_UNIVERSAL_IDENTIFIERS.taskRecordPage.tabs.home.widgets
+ .fields.universalIdentifier;
```
短いエイリアス `STANDARD_PAGE_LAYOUT` も利用できます:
diff --git a/packages/twenty-docs/l/ja/developers/extend/apps/logic/background-jobs.mdx b/packages/twenty-docs/l/ja/developers/extend/apps/logic/background-jobs.mdx
index 92ee75cf8d8..7c74e8ef6c3 100644
--- a/packages/twenty-docs/l/ja/developers/extend/apps/logic/background-jobs.mdx
+++ b/packages/twenty-docs/l/ja/developers/extend/apps/logic/background-jobs.mdx
@@ -6,10 +6,10 @@ icon: layer-group
ロジック関数の実行は、その `timeoutSeconds`(最大 900 秒)によって制限されます。 その時間内に完了できない処理 — フル再同期、レコードごとのファンアウト、レート制限を課してくるサードパーティ API など — は、より小さい実行単位に分割する必要があります。
-`enqueueJob` はまさにそれを行います。Twenty のワーカーに対して、あなたのアプリのロジック関数の 1 つを、独立したプロセスと独自のタイムアウト枠で後から実行するよう依頼します。 呼び出し元はすぐに戻ります。
+`enqueueJobs` はまさにそれを行います。Twenty のワーカーに、アプリのロジック関数のいずれかを後で実行するよう依頼します。ペイロードごとに 1 回、各実行は独自のプロセスと独自のタイムアウト枠で行われます。 呼び出し元はすぐに戻ります。
```text
- ┌─────────────────┐ enqueueJob(...) ┌──────────────┐ ┌────────────────────┐
+ ┌─────────────────┐ enqueueJobs(...) ┌──────────────┐ ┌────────────────────┐
│ Logic function │ ─────────────────▶ │ Job queue │──▶│ Logic function │
│ (returns now) │ │ (workers) │ │ (fresh run/timeout)│
└─────────────────┘ └──────────────┘ └────────────────────┘
@@ -17,34 +17,40 @@ icon: layer-group
## 実行をエンキューする
-`twenty-sdk/logic-function` から `enqueueJob` をインポートし、実行したいロジック関数の `universalIdentifier` を指定します。
+`twenty-sdk/logic-function` から `enqueueJobs` をインポートし、実行するロジック関数の `universalIdentifier` を指定して、エンキューする実行ごとに 1 つのペイロードを渡します。
```ts src/logic-functions/sync-all-contacts.ts
-import { enqueueJob } from 'twenty-sdk/logic-function';
+import { enqueueJobs } from 'twenty-sdk/logic-function';
-await enqueueJob({
+await enqueueJobs({
logicFunctionUniversalIdentifier: '9f1c3d7e-51b8-4a29-8f0d-7c4e2a6b1d33',
- payload: { page: 1 },
+ payloads: [{ page: 1 }],
});
```
-対象の関数は、他のトリガーとまったく同様に、ハンドラーの引数として `payload` を受け取ります。 対象のロジック関数は呼び出し元と**同じアプリケーション**に属している必要があります。別のアプリの関数をエンキューしようとすると、`Logic function not found` で拒否されます。
+各実行は、他のトリガーとまったく同様に、ハンドラーの引数としてペイロードを受け取ります。 対象は呼び出し元と**同じアプリケーション**に属している必要があります。別のアプリの関数をエンキューしようとすると、`Logic function not found` で拒否され、何もエンキューされません。 1 回の呼び出しで最大 `200` 個のペイロードを受け付けます。
<Note>
-`enqueueJob` は、ジョブが受け付けられた時点ですぐに戻り、ジョブが実行されたタイミングでは戻りません。 対象の結果は返しません。結果を後から読み戻す必要がある場合は、対象側で [key-value store](/l/ja/developers/extend/apps/logic/key-value-store) かワークスペースレコードに出力を書き込ませてください。
+`enqueueJobs` は、ジョブが受け付けられた時点ですぐに戻り、ジョブが実行された時点では戻りません。 対象の結果は返しません。結果を後から読み戻す必要がある場合は、各対象で生成したものを [key-value store](/l/ja/developers/extend/apps/logic/key-value-store) またはワークスペースレコードに書き込ませてください。
+</Note>
+
+<Note>
+呼び出しごとに単一のジョブをエンキューする古い `enqueueJob` ヘルパーは非推奨です。 代わりに、要素が 1 つの `payloads` リストで `enqueueJobs` を使用してください。
</Note>
## ジョブオプション
+オプションはバッチ内のすべての実行に適用されます。
+
| オプション | デフォルト | 範囲 | 機能 |
| ------------ | ----- | ------------------------ | --------------------------------------------------------------------------------- |
| `retryLimit` | `0` | `0`–`10` | 全体の追加キュー試行。 アプリケーションが要求する再試行回数は `3` に制限されます。 2 回実行しても安全なハンドラーに対してのみ、この値を増やしてください。 |
-| `delayMs` | `0` | `0`–`604800000` (7 days) | この時間が経過すると、その実行は実行可能になります。 |
+| `delayMs` | `0` | `0`–`604800000` (7 days) | 実行が実行可能になるまで、この時間待機します。 |
```ts
-await enqueueJob({
+await enqueueJobs({
logicFunctionUniversalIdentifier: '9f1c3d7e-51b8-4a29-8f0d-7c4e2a6b1d33',
- payload: { page: 1 },
+ payloads: [{ page: 1 }],
retryLimit: 3,
delayMs: 60_000,
});
@@ -96,7 +102,7 @@ export const handler = async (
```ts src/logic-functions/sync-contacts-page.ts
import { defineLogicFunction } from 'twenty-sdk/define';
-import { enqueueJob } from 'twenty-sdk/logic-function';
+import { enqueueJobs } from 'twenty-sdk/logic-function';
const SYNC_CONTACTS_PAGE = '9f1c3d7e-51b8-4a29-8f0d-7c4e2a6b1d33';
@@ -106,9 +112,9 @@ const handler = async (params: { cursor?: string }) => {
await importContacts(contacts);
if (nextCursor) {
- await enqueueJob({
+ await enqueueJobs({
logicFunctionUniversalIdentifier: SYNC_CONTACTS_PAGE,
- payload: { cursor: nextCursor },
+ payloads: [{ cursor: nextCursor }],
delayMs: 2_000,
});
}
@@ -126,20 +132,16 @@ export default defineLogicFunction({
## レコードごとにファンアウトする
-処理単位が自然にアイテムごとになる場合は、アイテムごとに 1 つのジョブをエンキューし、インラインでループするのではなく、ワーカーに並列で処理させます。
+処理が本質的にアイテムごとの場合は、1 回の呼び出しでアイテムごとに 1 つのジョブをエンキューし、インラインでループするのではなく、ワーカーに並列で処理させます。
```ts
const companies = await listCompaniesToEnrich();
-await Promise.all(
- companies.map((company) =>
- enqueueJob({
- logicFunctionUniversalIdentifier: ENRICH_COMPANY,
- payload: { companyId: company.id },
- retryLimit: 2,
- }),
- ),
-);
+await enqueueJobs({
+ logicFunctionUniversalIdentifier: ENRICH_COMPANY,
+ payloads: companies.map((company) => ({ companyId: company.id })),
+ retryLimit: 2,
+});
```
## 長時間実行タスクのためのベストプラクティス
@@ -150,7 +152,7 @@ await Promise.all(
```ts src/logic-functions/enrich-companies-batch.ts
import { defineLogicFunction } from 'twenty-sdk/define';
-import { enqueueJob, kv } from 'twenty-sdk/logic-function';
+import { enqueueJobs, kv } from 'twenty-sdk/logic-function';
const ENRICH_COMPANIES_BATCH = '3f9d1c02-8a44-4f0e-b1d7-9c2e5a7b4f10';
const CHUNK_SIZE = 50;
@@ -169,9 +171,9 @@ const handler = async (params: { offset?: number }) => {
await kv.set('enrich:progress', { offset: offset + companies.length });
if (companies.length === CHUNK_SIZE) {
- await enqueueJob({
+ await enqueueJobs({
logicFunctionUniversalIdentifier: ENRICH_COMPANIES_BATCH,
- payload: { offset: offset + CHUNK_SIZE },
+ payloads: [{ offset: offset + CHUNK_SIZE }],
});
}
diff --git a/packages/twenty-docs/l/ko/developers/extend/apps/layout/page-layouts.mdx b/packages/twenty-docs/l/ko/developers/extend/apps/layout/page-layouts.mdx
index d58d9a40fcf..37b01ab1fee 100644
--- a/packages/twenty-docs/l/ko/developers/extend/apps/layout/page-layouts.mdx
+++ b/packages/twenty-docs/l/ko/developers/extend/apps/layout/page-layouts.mdx
@@ -56,6 +56,7 @@ export default definePageLayout({
* 각 `tab`은 `title`, `position`, `layoutMode`를 사용해 페이지의 섹션을 정의합니다. 레코드 페이지와 독립형 페이지에는 `VERTICAL_LIST`를, 대시보드에는 `GRID`를 사용합니다. `VERTICAL_LIST` 탭에서는 단일 위젯이 전체 너비로 렌더링되며 탭 전체를 차지합니다. 여러 개의 위젯이 있으면 카드 형태로 위에서 아래로 쌓입니다. `GRID` 탭은 위젯의 개수와 관계없이 항상 12열 그리드에서 카드 형태로 배치되므로, 하나의 위젯이 페이지 전체를 채우도록 하려면 `VERTICAL_LIST`를 선택하세요.
* `layoutMode`를 명시적으로 설정하세요. 이를 생략하면 `STANDALONE_PAGE`에서는 `VERTICAL_LIST`가, 그 외의 경우에는 `GRID`가 기본값으로 설정되는데, 이는 레코드 페이지에서는 거의 원하지 않는 동작입니다.
* 탭 내부의 각 `widget`은 [front component](/l/ko/developers/extend/apps/layout/front-components), 관계 목록 또는 기타 기본 제공 위젯 타입을 렌더링할 수 있습니다.
+* `FRONT_COMPONENT` 위젯은 동일한 앱의 명령 메뉴 항목 범용 식별자로 이루어진 순서 있는 배열로 `headerCommandMenuItemUniversalIdentifiers`를 설정할 수 있습니다. 이러한 작업은 위젯 카드 헤더에 아이콘 버튼으로 표시되며, 명령 수준의 가용성 및 권한 검사를 유지합니다. 식별자는 고유해야 하며 앱이 설치될 때 확인 가능해야 합니다.
* 탭의 `position`은 탭의 순서를 제어합니다. 값을 더 높게 설정하면(예: 50) 기본 탭 뒤에 사용자 지정 탭을 배치할 수 있습니다.
### 필드 위젯
@@ -136,8 +137,10 @@ export default definePageLayoutTab({
각 레이아웃 항목은 `tabs`와 해당 `widgets`도 노출하므로, 모든 수준을 참조할 수 있습니다:
```ts
- STANDARD_PAGE_LAYOUT_UNIVERSAL_IDENTIFIERS.taskRecordPage.tabs.home.universalIdentifier
- STANDARD_PAGE_LAYOUT_UNIVERSAL_IDENTIFIERS.taskRecordPage.tabs.home.widgets.fields.universalIdentifier
+ STANDARD_PAGE_LAYOUT_UNIVERSAL_IDENTIFIERS.taskRecordPage.tabs.home
+ .universalIdentifier;
+ STANDARD_PAGE_LAYOUT_UNIVERSAL_IDENTIFIERS.taskRecordPage.tabs.home.widgets
+ .fields.universalIdentifier;
```
짧은 별칭인 `STANDARD_PAGE_LAYOUT`도 사용할 수 있습니다:
diff --git a/packages/twenty-docs/l/ko/developers/extend/apps/logic/background-jobs.mdx b/packages/twenty-docs/l/ko/developers/extend/apps/logic/background-jobs.mdx
index 722a151f562..87c6a28b68b 100644
--- a/packages/twenty-docs/l/ko/developers/extend/apps/logic/background-jobs.mdx
+++ b/packages/twenty-docs/l/ko/developers/extend/apps/logic/background-jobs.mdx
@@ -6,10 +6,10 @@ icon: layer-group
로직 함수 실행은 `timeoutSeconds`(최대 900초)로 제한됩니다. 해당 시간 안에 끝나지 않는 모든 작업(전체 재동기화, 레코드별 팬아웃, 속도 제한이 걸린 서드파티 API 등)은 더 작은 실행 단위로 나눠야 합니다.
-`enqueueJob`은 바로 그 일을 합니다. Twenty 워커에게 나중에 별도 프로세스와 별도의 타임아웃 한도 내에서 앱의 로직 함수 중 하나를 실행해 달라고 요청합니다. 호출은 즉시 반환됩니다.
+`enqueueJobs`는 바로 그 일을 합니다. Twenty 워커에게 나중에 앱의 로직 함수 중 하나를 실행해 달라고 요청하며, 각 페이로드당 한 번씩 실행되고 각 실행은 자체 프로세스에서 자체 타임아웃 한도로 처리됩니다. 호출은 즉시 반환됩니다.
```text
- ┌─────────────────┐ enqueueJob(...) ┌──────────────┐ ┌────────────────────┐
+ ┌─────────────────┐ enqueueJobs(...) ┌──────────────┐ ┌────────────────────┐
│ Logic function │ ─────────────────▶ │ Job queue │──▶│ Logic function │
│ (returns now) │ │ (workers) │ │ (fresh run/timeout)│
└─────────────────┘ └──────────────┘ └────────────────────┘
@@ -17,34 +17,40 @@ icon: layer-group
## 실행 대기열에 추가하기
-`twenty-sdk/logic-function`에서 `enqueueJob`을 가져와서, 실행하려는 로직 함수의 `universalIdentifier`를 가리키도록 설정하세요.
+`twenty-sdk/logic-function`에서 `enqueueJobs`를 가져와 실행할 로직 함수의 `universalIdentifier`를 지정하고, 대기열에 추가할 각 실행마다 하나의 페이로드를 전달하세요.
```ts src/logic-functions/sync-all-contacts.ts
-import { enqueueJob } from 'twenty-sdk/logic-function';
+import { enqueueJobs } from 'twenty-sdk/logic-function';
-await enqueueJob({
+await enqueueJobs({
logicFunctionUniversalIdentifier: '9f1c3d7e-51b8-4a29-8f0d-7c4e2a6b1d33',
- payload: { page: 1 },
+ payloads: [{ page: 1 }],
});
```
-대상 함수는 다른 트리거와 정확히 동일하게, 핸들러 인자로 `payload`를 전달받습니다. 대상 함수는 호출자와 **동일한 애플리케이션**에 속해야 합니다. 다른 앱의 함수를 대기열에 추가하려고 하면 `Logic function not found` 오류와 함께 거부됩니다.
+각 실행은 다른 모든 트리거와 정확히 동일하게 핸들러 인수로 해당 페이로드를 받습니다. 대상은 호출자와 **동일한 애플리케이션**에 속해야 합니다. 다른 앱의 함수를 대기열에 추가하려고 하면 `Logic function not found` 오류와 함께 거부되며 아무것도 대기열에 추가되지 않습니다. 한 번의 호출로 최대 `200`개의 페이로드를 허용합니다.
<Note>
-`enqueueJob`은 작업이 실행을 마쳤을 때가 아니라, 작업이 수락되는 즉시 반환됩니다. 대상 함수의 결과를 반환하지는 않습니다. 결과를 다시 읽어와야 한다면, 대상 함수가 생성한 내용을 [키-값 스토어](/l/ko/developers/extend/apps/logic/key-value-store) 또는 워크스페이스 레코드에 기록하도록 하세요.
+`enqueueJobs`는 작업이 실행되었을 때가 아니라 작업이 수락되는 즉시 반환됩니다. 대상들의 결과를 반환하지는 않습니다. 결과를 다시 읽어와야 한다면, 각 대상이 생성한 내용을 [키-값 스토어](/l/ko/developers/extend/apps/logic/key-value-store) 또는 워크스페이스 레코드에 기록하도록 하세요.
+</Note>
+
+<Note>
+호출당 하나의 작업을 대기열에 추가하는 이전 `enqueueJob` 도우미는 더 이상 사용되지 않습니다. 대신 요소가 하나인 `payloads` 목록과 함께 `enqueueJobs`를 사용하세요.
</Note>
## 작업 옵션
+옵션은 배치의 모든 실행에 적용됩니다.
+
| 옵션 | 기본값 | 범위 | 하는 일 |
| ------------ | --- | ------------------------ | ------------------------------------------------------------------------------- |
| `retryLimit` | `0` | `0`–`10` | 전체 추가 큐 시도 횟수. 애플리케이션에서 요청한 재시도는 `3`회로 제한됩니다. 두 번 실행해도 안전한 핸들러에 대해서만 이 값을 올리세요. |
| `delayMs` | `0` | `0`–`604800000` (7 days) | 실행이 가능해지기 전까지 이만큼 대기합니다. |
```ts
-await enqueueJob({
+await enqueueJobs({
logicFunctionUniversalIdentifier: '9f1c3d7e-51b8-4a29-8f0d-7c4e2a6b1d33',
- payload: { page: 1 },
+ payloads: [{ page: 1 }],
retryLimit: 3,
delayMs: 60_000,
});
@@ -96,7 +102,7 @@ export const handler = async (
```ts src/logic-functions/sync-contacts-page.ts
import { defineLogicFunction } from 'twenty-sdk/define';
-import { enqueueJob } from 'twenty-sdk/logic-function';
+import { enqueueJobs } from 'twenty-sdk/logic-function';
const SYNC_CONTACTS_PAGE = '9f1c3d7e-51b8-4a29-8f0d-7c4e2a6b1d33';
@@ -106,9 +112,9 @@ const handler = async (params: { cursor?: string }) => {
await importContacts(contacts);
if (nextCursor) {
- await enqueueJob({
+ await enqueueJobs({
logicFunctionUniversalIdentifier: SYNC_CONTACTS_PAGE,
- payload: { cursor: nextCursor },
+ payloads: [{ cursor: nextCursor }],
delayMs: 2_000,
});
}
@@ -126,20 +132,16 @@ export default defineLogicFunction({
## 레코드별로 팬아웃하기
-작업이 본질적으로 항목 단위일 때는, 항목마다 하나의 작업을 대기열에 추가하고, 워커들이 인라인 루프를 도는 대신 병렬로 처리하도록 하세요.
+작업이 본질적으로 항목 단위일 때는, 단일 호출에서 항목마다 하나의 작업을 대기열에 추가하고 워커들이 인라인 루프를 도는 대신 병렬로 처리하도록 하세요.
```ts
const companies = await listCompaniesToEnrich();
-await Promise.all(
- companies.map((company) =>
- enqueueJob({
- logicFunctionUniversalIdentifier: ENRICH_COMPANY,
- payload: { companyId: company.id },
- retryLimit: 2,
- }),
- ),
-);
+await enqueueJobs({
+ logicFunctionUniversalIdentifier: ENRICH_COMPANY,
+ payloads: companies.map((company) => ({ companyId: company.id })),
+ retryLimit: 2,
+});
```
## 장시간 실행 작업을 위한 모범 사례
@@ -150,7 +152,7 @@ await Promise.all(
```ts src/logic-functions/enrich-companies-batch.ts
import { defineLogicFunction } from 'twenty-sdk/define';
-import { enqueueJob, kv } from 'twenty-sdk/logic-function';
+import { enqueueJobs, kv } from 'twenty-sdk/logic-function';
const ENRICH_COMPANIES_BATCH = '3f9d1c02-8a44-4f0e-b1d7-9c2e5a7b4f10';
const CHUNK_SIZE = 50;
@@ -169,9 +171,9 @@ const handler = async (params: { offset?: number }) => {
await kv.set('enrich:progress', { offset: offset + companies.length });
if (companies.length === CHUNK_SIZE) {
- await enqueueJob({
+ await enqueueJobs({
logicFunctionUniversalIdentifier: ENRICH_COMPANIES_BATCH,
- payload: { offset: offset + CHUNK_SIZE },
+ payloads: [{ offset: offset + CHUNK_SIZE }],
});
}
diff --git a/packages/twenty-docs/l/pt/developers/extend/apps/layout/page-layouts.mdx b/packages/twenty-docs/l/pt/developers/extend/apps/layout/page-layouts.mdx
index ba6014c3ada..022bababcd9 100644
--- a/packages/twenty-docs/l/pt/developers/extend/apps/layout/page-layouts.mdx
+++ b/packages/twenty-docs/l/pt/developers/extend/apps/layout/page-layouts.mdx
@@ -56,6 +56,7 @@ export default definePageLayout({
* Cada `tab` define uma seção da página com um `title`, `position` e `layoutMode`: `VERTICAL_LIST` para páginas de registro e páginas independentes, `GRID` para dashboards. Em uma aba `VERTICAL_LIST`, um único widget é renderizado em largura total e ocupa toda a aba; com vários widgets, eles são empilhados como cards. Uma aba `GRID` sempre distribui seus widgets como cards em uma grade de 12 colunas, independentemente da quantidade, portanto escolha `VERTICAL_LIST` quando quiser que um único widget preencha a página.
* Defina `layoutMode` explicitamente. Omití-lo faz com que você obtenha `VERTICAL_LIST` em uma `STANDALONE_PAGE` e `GRID` em todos os outros casos, o que raramente é o que você deseja em uma página de registro.
* Cada `widget` dentro de uma aba pode renderizar um [front component](/l/pt/developers/extend/apps/layout/front-components), uma lista de relações ou outros tipos de widget nativos.
+* Um widget `FRONT_COMPONENT` pode definir `headerCommandMenuItemUniversalIdentifiers` como uma matriz ordenada de identificadores universais de itens de menu de comandos do mesmo app. Essas ações aparecem como botões de ícone no cabeçalho do cartão do widget e mantêm suas verificações de disponibilidade e permissões no nível do comando. Os identificadores devem ser exclusivos e devem ser resolvidos quando o app for instalado.
* `position` nas abas controla sua ordem. Use valores mais altos (por exemplo, 50) para colocar abas personalizadas após as nativas.
### Widgets de campos
@@ -136,8 +137,10 @@ export default definePageLayoutTab({
Cada entrada de layout também expõe suas `tabs` e seus `widgets`, para que você possa fazer referência a qualquer nível:
```ts
- STANDARD_PAGE_LAYOUT_UNIVERSAL_IDENTIFIERS.taskRecordPage.tabs.home.universalIdentifier
- STANDARD_PAGE_LAYOUT_UNIVERSAL_IDENTIFIERS.taskRecordPage.tabs.home.widgets.fields.universalIdentifier
+ STANDARD_PAGE_LAYOUT_UNIVERSAL_IDENTIFIERS.taskRecordPage.tabs.home
+ .universalIdentifier;
+ STANDARD_PAGE_LAYOUT_UNIVERSAL_IDENTIFIERS.taskRecordPage.tabs.home.widgets
+ .fields.universalIdentifier;
```
Um alias abreviado `STANDARD_PAGE_LAYOUT` também está disponível:
diff --git a/packages/twenty-docs/l/pt/developers/extend/apps/logic/background-jobs.mdx b/packages/twenty-docs/l/pt/developers/extend/apps/logic/background-jobs.mdx
index 790c93f84ba..8741df0884b 100644
--- a/packages/twenty-docs/l/pt/developers/extend/apps/logic/background-jobs.mdx
+++ b/packages/twenty-docs/l/pt/developers/extend/apps/logic/background-jobs.mdx
@@ -6,45 +6,51 @@ icon: layer-group
Uma execução de função de lógica é limitada pelo seu `timeoutSeconds` (máximo de 900 segundos). Qualquer coisa que não consiga terminar nesse intervalo — uma re-sincronização completa, uma distribuição por registro, uma API de terceiros que impõe limitações de taxa — precisa ser dividida em execuções menores.
-`enqueueJob` faz exatamente isso: solicita aos workers do Twenty que executem mais tarde uma das funções de lógica do seu aplicativo, em seu próprio processo, com seu próprio tempo limite. O chamador retorna imediatamente.
+`enqueueJobs` faz exatamente isso: solicita aos workers do Twenty que executem mais tarde uma das funções de lógica do seu aplicativo, uma vez por payload, cada execução em seu próprio processo com seu próprio orçamento de tempo limite. O chamador retorna imediatamente.
```text
- ┌─────────────────┐ enqueueJob(...) ┌──────────────┐ ┌────────────────────┐
+ ┌─────────────────┐ enqueueJobs(...) ┌──────────────┐ ┌────────────────────┐
│ Logic function │ ─────────────────▶ │ Job queue │──▶│ Logic function │
│ (returns now) │ │ (workers) │ │ (fresh run/timeout)│
└─────────────────┘ └──────────────┘ └────────────────────┘
```
-## Colocar uma execução na fila
+## Colocar execuções na fila
-Importe `enqueueJob` de `twenty-sdk/logic-function` e aponte-o para o `universalIdentifier` da função de lógica que você quer executar.
+Importe `enqueueJobs` de `twenty-sdk/logic-function`, aponte-o para o `universalIdentifier` da função de lógica a ser executada e passe um payload por execução para colocar na fila.
```ts src/logic-functions/sync-all-contacts.ts
-import { enqueueJob } from 'twenty-sdk/logic-function';
+import { enqueueJobs } from 'twenty-sdk/logic-function';
-await enqueueJob({
+await enqueueJobs({
logicFunctionUniversalIdentifier: '9f1c3d7e-51b8-4a29-8f0d-7c4e2a6b1d33',
- payload: { page: 1 },
+ payloads: [{ page: 1 }],
});
```
-A função de destino recebe `payload` como argumento do handler, exatamente como qualquer outro gatilho. Ela deve pertencer à **mesma aplicação** que quem a chama — colocar na fila a função de outra aplicação é rejeitado com `Logic function not found`.
+Cada execução recebe seu payload como argumento do handler, exatamente como qualquer outro gatilho. O destino deve pertencer à **mesma aplicação** que quem o chama — colocar na fila a função de outra aplicação é rejeitado com `Logic function not found` e nada é colocado na fila. Uma única chamada aceita até `200` payloads.
<Note>
-`enqueueJob` retorna assim que o job é aceito, não quando ele é executado. Ele não retorna o resultado do destino — faça o destino gravar o que produzir no [repositório de chave-valor](/l/pt/developers/extend/apps/logic/key-value-store) ou em um registro do workspace se você precisar ler isso de volta.
+`enqueueJobs` retorna assim que os jobs são aceitos, não quando são executados. Ele não retorna os resultados dos destinos — faça cada destino gravar o que produzir no [repositório de chave-valor](/l/pt/developers/extend/apps/logic/key-value-store) ou em um registro do workspace se você precisar ler isso de volta.
+</Note>
+
+<Note>
+O auxiliar `enqueueJob` mais antigo, que coloca um único job na fila por chamada, está obsoleto. Use `enqueueJobs` com uma lista `payloads` de um elemento em vez disso.
</Note>
## Opções do job
+As opções se aplicam a todas as execuções no lote.
+
| Opção | Padrão | Intervalo | O que faz |
| ------------ | ------ | ------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `retryLimit` | `0` | `0`–`10` | Total de tentativas adicionais na fila. As novas tentativas solicitadas pelo aplicativo são limitadas a `3`. Só aumente isso para handlers que sejam seguros para serem executados duas vezes. |
-| `delayMs` | `0` | `0`–`604800000` (7 dias) | Espere esse tempo antes de a execução se tornar elegível. |
+| `delayMs` | `0` | `0`–`604800000` (7 dias) | Espere esse tempo antes de as execuções se tornarem elegíveis. |
```ts
-await enqueueJob({
+await enqueueJobs({
logicFunctionUniversalIdentifier: '9f1c3d7e-51b8-4a29-8f0d-7c4e2a6b1d33',
- payload: { page: 1 },
+ payloads: [{ page: 1 }],
retryLimit: 3,
delayMs: 60_000,
});
@@ -96,7 +102,7 @@ O formato clássico é uma função que coloca *a si mesma* na fila com o próxi
```ts src/logic-functions/sync-contacts-page.ts
import { defineLogicFunction } from 'twenty-sdk/define';
-import { enqueueJob } from 'twenty-sdk/logic-function';
+import { enqueueJobs } from 'twenty-sdk/logic-function';
const SYNC_CONTACTS_PAGE = '9f1c3d7e-51b8-4a29-8f0d-7c4e2a6b1d33';
@@ -106,9 +112,9 @@ const handler = async (params: { cursor?: string }) => {
await importContacts(contacts);
if (nextCursor) {
- await enqueueJob({
+ await enqueueJobs({
logicFunctionUniversalIdentifier: SYNC_CONTACTS_PAGE,
- payload: { cursor: nextCursor },
+ payloads: [{ cursor: nextCursor }],
delayMs: 2_000,
});
}
@@ -126,20 +132,16 @@ export default defineLogicFunction({
## Ramificar por registro
-Quando o trabalho é naturalmente por item, coloque um job por item na fila e deixe os workers processarem em paralelo em vez de fazer o loop inline.
+Quando o trabalho é naturalmente por item, coloque um job por item na fila em uma única chamada e deixe os workers processá-los em paralelo em vez de fazer o loop inline.
```ts
const companies = await listCompaniesToEnrich();
-await Promise.all(
- companies.map((company) =>
- enqueueJob({
- logicFunctionUniversalIdentifier: ENRICH_COMPANY,
- payload: { companyId: company.id },
- retryLimit: 2,
- }),
- ),
-);
+await enqueueJobs({
+ logicFunctionUniversalIdentifier: ENRICH_COMPANY,
+ payloads: companies.map((company) => ({ companyId: company.id })),
+ retryLimit: 2,
+});
```
## Boas práticas para trabalho de longa duração
@@ -150,7 +152,7 @@ Uma execução que tenta fazer tudo é o modo de falha — ela atinge o tempo li
```ts src/logic-functions/enrich-companies-batch.ts
import { defineLogicFunction } from 'twenty-sdk/define';
-import { enqueueJob, kv } from 'twenty-sdk/logic-function';
+import { enqueueJobs, kv } from 'twenty-sdk/logic-function';
const ENRICH_COMPANIES_BATCH = '3f9d1c02-8a44-4f0e-b1d7-9c2e5a7b4f10';
const CHUNK_SIZE = 50;
@@ -169,9 +171,9 @@ const handler = async (params: { offset?: number }) => {
await kv.set('enrich:progress', { offset: offset + companies.length });
if (companies.length === CHUNK_SIZE) {
- await enqueueJob({
+ await enqueueJobs({
logicFunctionUniversalIdentifier: ENRICH_COMPANIES_BATCH,
- payload: { offset: offset + CHUNK_SIZE },
+ payloads: [{ offset: offset + CHUNK_SIZE }],
});
}
diff --git a/packages/twenty-docs/l/ro/developers/extend/apps/layout/page-layouts.mdx b/packages/twenty-docs/l/ro/developers/extend/apps/layout/page-layouts.mdx
index ef625bf2483..727852e6790 100644
--- a/packages/twenty-docs/l/ro/developers/extend/apps/layout/page-layouts.mdx
+++ b/packages/twenty-docs/l/ro/developers/extend/apps/layout/page-layouts.mdx
@@ -56,6 +56,7 @@ export default definePageLayout({
* Fiecare `tab` definește o secțiune a paginii cu un `title`, `position` și `layoutMode`: `VERTICAL_LIST` pentru pagini ale înregistrărilor și pagini independente, `GRID` pentru dashboard-uri. Într-un tab de tip `VERTICAL_LIST`, un singur widget este redat pe toată lățimea și ocupă întregul tab; cu mai multe widget-uri, acestea sunt aranjate în stivă, sub formă de carduri. Un tab de tip `GRID` așază întotdeauna widget-urile sub formă de carduri pe o grilă cu 12 coloane, indiferent de numărul lor, așa că alege `VERTICAL_LIST` atunci când vrei ca un singur widget să umple pagina.
* Setează explicit `layoutMode`. Dacă îl omiți, vei obține `VERTICAL_LIST` pe un `STANDALONE_PAGE` și `GRID` în rest, ceea ce rareori îți dorești pe o pagină de înregistrare.
* Fiecare `widget` dintr-o filă poate reda un [front component](/l/ro/developers/extend/apps/layout/front-components), o listă de relații sau alte tipuri de widgeturi integrate.
+* Un widget `FRONT_COMPONENT` poate seta `headerCommandMenuItemUniversalIdentifiers` la o matrice ordonată de identificatori universali ai elementelor de meniu de comandă din aceeași aplicație. Aceste acțiuni apar ca butoane cu pictograme în antetul cardului widgetului și își păstrează verificările de disponibilitate și de permisiuni la nivel de comandă. Identificatorii trebuie să fie unici și trebuie să se rezolve atunci când aplicația este instalată.
* `position` pe file le controlează ordinea. Folosește valori mai mari (de ex., 50) pentru a plasa filele personalizate după cele integrate.
### Widget-uri Câmp
@@ -136,8 +137,10 @@ export default definePageLayoutTab({
Fiecare intrare de layout își expune, de asemenea, `tabs` și `widgets`, astfel încât puteți face referire la orice nivel:
```ts
- STANDARD_PAGE_LAYOUT_UNIVERSAL_IDENTIFIERS.taskRecordPage.tabs.home.universalIdentifier
- STANDARD_PAGE_LAYOUT_UNIVERSAL_IDENTIFIERS.taskRecordPage.tabs.home.widgets.fields.universalIdentifier
+ STANDARD_PAGE_LAYOUT_UNIVERSAL_IDENTIFIERS.taskRecordPage.tabs.home
+ .universalIdentifier;
+ STANDARD_PAGE_LAYOUT_UNIVERSAL_IDENTIFIERS.taskRecordPage.tabs.home.widgets
+ .fields.universalIdentifier;
```
Este disponibil și un alias scurt `STANDARD_PAGE_LAYOUT`:
diff --git a/packages/twenty-docs/l/ro/developers/extend/apps/logic/background-jobs.mdx b/packages/twenty-docs/l/ro/developers/extend/apps/logic/background-jobs.mdx
index e271c1505a1..3ed6232e9c0 100644
--- a/packages/twenty-docs/l/ro/developers/extend/apps/logic/background-jobs.mdx
+++ b/packages/twenty-docs/l/ro/developers/extend/apps/logic/background-jobs.mdx
@@ -6,45 +6,51 @@ icon: layer-group
O rulare a unei funcții de logică este limitată de `timeoutSeconds` (maximum 900 de secunde). Orice lucru care nu poate fi finalizat în acel interval — o resincronizare completă, un fan-out per înregistrare, un API de la o terță parte care aplică limitare de rată — trebuie împărțit în execuții mai mici.
-`enqueueJob` face exact asta: le cere lucrătorilor Twenty să ruleze una dintre funcțiile de logică ale aplicației tale mai târziu, în propriul său proces, cu propriul său buget de timeout. Apelantul returnează imediat.
+`enqueueJobs` face exact asta: le cere lucrătorilor Twenty să ruleze mai târziu una dintre funcțiile de logică ale aplicației tale, o dată pentru fiecare payload, fiecare rulare în propriul său proces, cu propriul său buget de timeout. Apelantul returnează imediat.
```text
- ┌─────────────────┐ enqueueJob(...) ┌──────────────┐ ┌────────────────────┐
+ ┌─────────────────┐ enqueueJobs(...) ┌──────────────┐ ┌────────────────────┐
│ Logic function │ ─────────────────▶ │ Job queue │──▶│ Logic function │
│ (returns now) │ │ (workers) │ │ (fresh run/timeout)│
└─────────────────┘ └──────────────┘ └────────────────────┘
```
-## Pune în coadă o rulare
+## Pune rulările în coadă
-Importă `enqueueJob` din `twenty-sdk/logic-function` și indică-l către `universalIdentifier` al funcției logice pe care vrei să o rulezi.
+Importă `enqueueJobs` din `twenty-sdk/logic-function`, indică-l către `universalIdentifier` al funcției logice de rulat și transmite câte un payload pentru fiecare rulare funcției enqueue.
```ts src/logic-functions/sync-all-contacts.ts
-import { enqueueJob } from 'twenty-sdk/logic-function';
+import { enqueueJobs } from 'twenty-sdk/logic-function';
-await enqueueJob({
+await enqueueJobs({
logicFunctionUniversalIdentifier: '9f1c3d7e-51b8-4a29-8f0d-7c4e2a6b1d33',
- payload: { page: 1 },
+ payloads: [{ page: 1 }],
});
```
-Funcția țintă primește `payload` ca argument al handlerului, exact ca orice alt declanșator. Ea trebuie să aparțină **aceleiași aplicații** ca apelantul — punerea în coadă a funcției altei aplicații este respinsă cu `Logic function not found`.
+Fiecare rulare primește payloadul său ca argument al handlerului, exact ca orice alt declanșator. Ținta trebuie să aparțină **aceleiași aplicații** ca apelantul — punerea în coadă a funcției altei aplicații este respinsă cu `Logic function not found` și nu se pune nimic în coadă. Un singur apel acceptă până la `200` payloaduri.
<Note>
-`enqueueJob` revine imediat ce jobul este acceptat, nu când a fost rulat. Nu întoarce rezultatul țintei — fă ca ținta să scrie ce produce în [magazinul cheie-valoare](/l/ro/developers/extend/apps/logic/key-value-store) sau într-o înregistrare din spațiul de lucru dacă trebuie să îl citești ulterior.
+`enqueueJobs` revine imediat ce joburile sunt acceptate, nu când au fost rulate. Nu întoarce rezultatele țintelor — fă ca fiecare țintă să scrie ce produce în [magazinul cheie-valoare](/l/ro/developers/extend/apps/logic/key-value-store) sau într-o înregistrare din spațiul de lucru dacă trebuie să le citești ulterior.
+</Note>
+
+<Note>
+Ajutorul mai vechi `enqueueJob`, care pune în coadă un singur job per apel, este depreciat. Folosește în schimb `enqueueJobs` cu o listă `payloads` cu un element.
</Note>
## Opțiuni job
+Opțiunile se aplică fiecărei rulări din lot.
+
| Opțiune | Implicit | Interval | Ce face |
| ------------ | -------- | ------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `retryLimit` | `0` | `0`–`10` | Numărul total de încercări suplimentare în coadă. Reîncercările solicitate de aplicație sunt limitate la `3`. Crește această valoare numai pentru handleri care sunt siguri de rulat de două ori. |
-| `delayMs` | `0` | `0`–`604800000` (7 zile) | Așteaptă atât timp înainte ca rularea să devină eligibilă. |
+| `delayMs` | `0` | `0`–`604800000` (7 zile) | Așteaptă atât timp înainte ca rulările să devină eligibile. |
```ts
-await enqueueJob({
+await enqueueJobs({
logicFunctionUniversalIdentifier: '9f1c3d7e-51b8-4a29-8f0d-7c4e2a6b1d33',
- payload: { page: 1 },
+ payloads: [{ page: 1 }],
retryLimit: 3,
delayMs: 60_000,
});
@@ -96,7 +102,7 @@ Forma clasică este o funcție care pune în coadă *ea însăși* cu următorul
```ts src/logic-functions/sync-contacts-page.ts
import { defineLogicFunction } from 'twenty-sdk/define';
-import { enqueueJob } from 'twenty-sdk/logic-function';
+import { enqueueJobs } from 'twenty-sdk/logic-function';
const SYNC_CONTACTS_PAGE = '9f1c3d7e-51b8-4a29-8f0d-7c4e2a6b1d33';
@@ -106,9 +112,9 @@ const handler = async (params: { cursor?: string }) => {
await importContacts(contacts);
if (nextCursor) {
- await enqueueJob({
+ await enqueueJobs({
logicFunctionUniversalIdentifier: SYNC_CONTACTS_PAGE,
- payload: { cursor: nextCursor },
+ payloads: [{ cursor: nextCursor }],
delayMs: 2_000,
});
}
@@ -126,20 +132,16 @@ export default defineLogicFunction({
## Dispersare pe înregistrare
-Când munca este în mod natural pe element, pune în coadă un job per element și lasă workerii să le proceseze în paralel în loc să iterezi inline.
+Când munca este în mod natural pe element, pune în coadă un job per element într-un singur apel și lasă workerii să le proceseze în paralel în loc să iterezi inline.
```ts
const companies = await listCompaniesToEnrich();
-await Promise.all(
- companies.map((company) =>
- enqueueJob({
- logicFunctionUniversalIdentifier: ENRICH_COMPANY,
- payload: { companyId: company.id },
- retryLimit: 2,
- }),
- ),
-);
+await enqueueJobs({
+ logicFunctionUniversalIdentifier: ENRICH_COMPANY,
+ payloads: companies.map((company) => ({ companyId: company.id })),
+ retryLimit: 2,
+});
```
## Bune practici pentru muncă de lungă durată
@@ -150,7 +152,7 @@ O rulare care încearcă să facă totul este modul de eșec — atinge timeout-
```ts src/logic-functions/enrich-companies-batch.ts
import { defineLogicFunction } from 'twenty-sdk/define';
-import { enqueueJob, kv } from 'twenty-sdk/logic-function';
+import { enqueueJobs, kv } from 'twenty-sdk/logic-function';
const ENRICH_COMPANIES_BATCH = '3f9d1c02-8a44-4f0e-b1d7-9c2e5a7b4f10';
const CHUNK_SIZE = 50;
@@ -169,9 +171,9 @@ const handler = async (params: { offset?: number }) => {
await kv.set('enrich:progress', { offset: offset + companies.length });
if (companies.length === CHUNK_SIZE) {
- await enqueueJob({
+ await enqueueJobs({
logicFunctionUniversalIdentifier: ENRICH_COMPANIES_BATCH,
- payload: { offset: offset + CHUNK_SIZE },
+ payloads: [{ offset: offset + CHUNK_SIZE }],
});
}
diff --git a/packages/twenty-docs/l/ru/developers/extend/apps/layout/page-layouts.mdx b/packages/twenty-docs/l/ru/developers/extend/apps/layout/page-layouts.mdx
index 6211cc7a984..12ef83ba52c 100644
--- a/packages/twenty-docs/l/ru/developers/extend/apps/layout/page-layouts.mdx
+++ b/packages/twenty-docs/l/ru/developers/extend/apps/layout/page-layouts.mdx
@@ -56,6 +56,7 @@ export default definePageLayout({
* Каждая `tab` определяет раздел страницы с `title`, `position` и `layoutMode`: `VERTICAL_LIST` для страниц записей и автономных страниц, `GRID` для панелей мониторинга. Во вкладке `VERTICAL_LIST` один виджет отображается на всю ширину и занимает всю вкладку; при нескольких виджетах они располагаются в виде карточек. Вкладка `GRID` всегда раскладывает свои виджеты в виде карточек на 12‑колоночной сетке, независимо от их количества, так что выбирайте `VERTICAL_LIST`, когда нужно, чтобы один виджет заполнял страницу.
* Явно задайте `layoutMode`. Если его не указывать, вы получите `VERTICAL_LIST` на `STANDALONE_PAGE` и `GRID` в остальных случаях, что редко бывает нужно на странице записи.
* Каждый `widget` внутри вкладки может отображать [front component](/l/ru/developers/extend/apps/layout/front-components), список связей или другие встроенные типы виджетов.
+* Виджет `FRONT_COMPONENT` может задавать для `headerCommandMenuItemUniversalIdentifiers` упорядоченный массив универсальных идентификаторов элементов меню команд из того же приложения. Эти действия отображаются как кнопки со значками в заголовке карточки виджета и сохраняют доступность и проверки разрешений на уровне команд. Идентификаторы должны быть уникальными и разрешаться при установке приложения.
* `position` у вкладок управляет их порядком. Используйте большие значения (например, 50), чтобы разместить пользовательские вкладки после встроенных.
### Виджеты полей
@@ -136,8 +137,10 @@ export default definePageLayoutTab({
Каждый элемент макета также предоставляет свои `tabs` и их `widgets`, поэтому вы можете ссылаться на любой уровень:
```ts
- STANDARD_PAGE_LAYOUT_UNIVERSAL_IDENTIFIERS.taskRecordPage.tabs.home.universalIdentifier
- STANDARD_PAGE_LAYOUT_UNIVERSAL_IDENTIFIERS.taskRecordPage.tabs.home.widgets.fields.universalIdentifier
+ STANDARD_PAGE_LAYOUT_UNIVERSAL_IDENTIFIERS.taskRecordPage.tabs.home
+ .universalIdentifier;
+ STANDARD_PAGE_LAYOUT_UNIVERSAL_IDENTIFIERS.taskRecordPage.tabs.home.widgets
+ .fields.universalIdentifier;
```
Также доступен короткий псевдоним `STANDARD_PAGE_LAYOUT`:
diff --git a/packages/twenty-docs/l/ru/developers/extend/apps/logic/background-jobs.mdx b/packages/twenty-docs/l/ru/developers/extend/apps/logic/background-jobs.mdx
index 935a7c52a85..05c74f962bb 100644
--- a/packages/twenty-docs/l/ru/developers/extend/apps/logic/background-jobs.mdx
+++ b/packages/twenty-docs/l/ru/developers/extend/apps/logic/background-jobs.mdx
@@ -6,45 +6,51 @@ icon: layer-group
Запуск логической функции ограничен значением `timeoutSeconds` (максимум 900 секунд). Любая задача, которая не может завершиться за это время — полная повторная синхронизация, разветвление по каждой записи, сторонний API, который ограничивает вас по скорости, — должна быть разделена на более мелкие запуски.
-`enqueueJob` делает именно это: он просит воркеров Twenty позже запустить одну из логических функций вашего приложения в отдельном процессе с собственным лимитом времени. Вызов возвращается немедленно.
+`enqueueJobs` делает именно это: он просит воркеров Twenty позже запустить одну из логических функций вашего приложения, по одному разу для каждой полезной нагрузки, каждый запуск в отдельном процессе с собственным лимитом времени. Вызов возвращается немедленно.
```text
- ┌─────────────────┐ enqueueJob(...) ┌──────────────┐ ┌────────────────────┐
+ ┌─────────────────┐ enqueueJobs(...) ┌──────────────┐ ┌────────────────────┐
│ Logic function │ ─────────────────▶ │ Job queue │──▶│ Logic function │
│ (returns now) │ │ (workers) │ │ (fresh run/timeout)│
└─────────────────┘ └──────────────┘ └────────────────────┘
```
-## Поставить запуск в очередь
+## Постановка запусков в очередь
-Импортируйте `enqueueJob` из `twenty-sdk/logic-function` и укажите `universalIdentifier` логической функции, которую вы хотите запустить.
+Импортируйте `enqueueJobs` из `twenty-sdk/logic-function`, укажите `universalIdentifier` логической функции для запуска и передайте в очередь по одной полезной нагрузке для каждого запуска.
```ts src/logic-functions/sync-all-contacts.ts
-import { enqueueJob } from 'twenty-sdk/logic-function';
+import { enqueueJobs } from 'twenty-sdk/logic-function';
-await enqueueJob({
+await enqueueJobs({
logicFunctionUniversalIdentifier: '9f1c3d7e-51b8-4a29-8f0d-7c4e2a6b1d33',
- payload: { page: 1 },
+ payloads: [{ page: 1 }],
});
```
-Целевая функция получает `payload` как аргумент обработчика, точно так же, как любой другой триггер. Она должна принадлежать **тому же приложению**, что и вызывающая сторона — постановка в очередь функции другого приложения будет отклонена с ошибкой `Logic function not found`.
+Каждый запуск получает свою полезную нагрузку в качестве аргумента обработчика, точно так же, как любой другой триггер. Целевая функция должна принадлежать **тому же приложению**, что и вызывающая сторона — постановка в очередь функции другого приложения будет отклонена с ошибкой `Logic function not found`, и ничего не будет поставлено в очередь. Один вызов принимает до `200` полезных нагрузок.
<Note>
-`enqueueJob` возвращает управление, как только задание принято, а не когда оно выполнено. Он не возвращает результат целевой функции — если вам нужно потом его прочитать, пусть целевая функция запишет результат в [key-value store](/l/ru/developers/extend/apps/logic/key-value-store) или в запись рабочего пространства.
+`enqueueJobs` возвращает управление, как только задания приняты, а не когда они выполнены. Он не возвращает результаты целевых функций — если вам нужно потом их прочитать, пусть каждая целевая функция запишет то, что она создаёт, в [key-value store](/l/ru/developers/extend/apps/logic/key-value-store) или в запись рабочего пространства.
+</Note>
+
+<Note>
+Старый помощник `enqueueJob`, который добавляет в очередь одно задание за вызов, устарел. Вместо этого используйте `enqueueJobs` со списком `payloads`, состоящим из одного элемента.
</Note>
## Параметры задания
+Параметры применяются к каждому запуску в пакете.
+
| Вариант | По умолчанию | Диапазон | Что делает |
| ------------ | ------------ | ------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `retryLimit` | `0` | `0`–`10` | Общее количество дополнительных попыток постановки в очередь. Количество повторных попыток, запрошенных приложением, ограничено значением `3`. Увеличивайте это значение только для обработчиков, которые безопасно запускать дважды. |
-| `delayMs` | `0` | `0`–`604800000` (7 дней) | Сколько ждать, прежде чем запуск станет допустимым к выполнению. |
+| `delayMs` | `0` | `0`–`604800000` (7 дней) | Сколько ждать, прежде чем запуски станут допустимыми к выполнению. |
```ts
-await enqueueJob({
+await enqueueJobs({
logicFunctionUniversalIdentifier: '9f1c3d7e-51b8-4a29-8f0d-7c4e2a6b1d33',
- payload: { page: 1 },
+ payloads: [{ page: 1 }],
retryLimit: 3,
delayMs: 60_000,
});
@@ -96,7 +102,7 @@ export const handler = async (
```ts src/logic-functions/sync-contacts-page.ts
import { defineLogicFunction } from 'twenty-sdk/define';
-import { enqueueJob } from 'twenty-sdk/logic-function';
+import { enqueueJobs } from 'twenty-sdk/logic-function';
const SYNC_CONTACTS_PAGE = '9f1c3d7e-51b8-4a29-8f0d-7c4e2a6b1d33';
@@ -106,9 +112,9 @@ const handler = async (params: { cursor?: string }) => {
await importContacts(contacts);
if (nextCursor) {
- await enqueueJob({
+ await enqueueJobs({
logicFunctionUniversalIdentifier: SYNC_CONTACTS_PAGE,
- payload: { cursor: nextCursor },
+ payloads: [{ cursor: nextCursor }],
delayMs: 2_000,
});
}
@@ -126,20 +132,16 @@ export default defineLogicFunction({
## Разветвление по каждой записи
-Когда работа естественным образом выполняется по отдельным элементам, поставьте по одному заданию на элемент и позвольте воркерам обрабатывать их параллельно, вместо того чтобы перебирать элементы в цикле внутри одной функции.
+Когда работа естественным образом выполняется по отдельным элементам, добавляйте в очередь по одному заданию на элемент за один вызов и позвольте воркерам обрабатывать их параллельно, вместо того чтобы перебирать элементы в цикле непосредственно в коде.
```ts
const companies = await listCompaniesToEnrich();
-await Promise.all(
- companies.map((company) =>
- enqueueJob({
- logicFunctionUniversalIdentifier: ENRICH_COMPANY,
- payload: { companyId: company.id },
- retryLimit: 2,
- }),
- ),
-);
+await enqueueJobs({
+ logicFunctionUniversalIdentifier: ENRICH_COMPANY,
+ payloads: companies.map((company) => ({ companyId: company.id })),
+ retryLimit: 2,
+});
```
## Рекомендации для длительной работы
@@ -150,7 +152,7 @@ await Promise.all(
```ts src/logic-functions/enrich-companies-batch.ts
import { defineLogicFunction } from 'twenty-sdk/define';
-import { enqueueJob, kv } from 'twenty-sdk/logic-function';
+import { enqueueJobs, kv } from 'twenty-sdk/logic-function';
const ENRICH_COMPANIES_BATCH = '3f9d1c02-8a44-4f0e-b1d7-9c2e5a7b4f10';
const CHUNK_SIZE = 50;
@@ -169,9 +171,9 @@ const handler = async (params: { offset?: number }) => {
await kv.set('enrich:progress', { offset: offset + companies.length });
if (companies.length === CHUNK_SIZE) {
- await enqueueJob({
+ await enqueueJobs({
logicFunctionUniversalIdentifier: ENRICH_COMPANIES_BATCH,
- payload: { offset: offset + CHUNK_SIZE },
+ payloads: [{ offset: offset + CHUNK_SIZE }],
});
}
diff --git a/packages/twenty-docs/l/tr/developers/extend/apps/layout/page-layouts.mdx b/packages/twenty-docs/l/tr/developers/extend/apps/layout/page-layouts.mdx
index 18d31de449e..9549a0d527e 100644
--- a/packages/twenty-docs/l/tr/developers/extend/apps/layout/page-layouts.mdx
+++ b/packages/twenty-docs/l/tr/developers/extend/apps/layout/page-layouts.mdx
@@ -56,6 +56,7 @@ export default definePageLayout({
* Her `tab`, bir `title`, `position` ve `layoutMode` ile sayfanın bir bölümünü tanımlar: kayıt sayfaları ve bağımsız sayfalar için `VERTICAL_LIST`, panolar için `GRID`. Bir `VERTICAL_LIST` sekmesinde tek bir bileşen tam genişlikte görüntülenir ve tüm sekmeyi kaplar; birden fazla bileşen varsa kartlar halinde üst üste dizilir. Bir `GRID` sekmesi, bileşenlerinin sayısı ne olursa olsun, bunları her zaman 12 sütunlu bir ızgarada kartlar olarak düzenler; bu nedenle, bir bileşenin sayfayı doldurmasını istediğinizde `VERTICAL_LIST` seçin.
* `layoutMode` değerini açıkça ayarlayın. Bunu atlamak, bir `STANDALONE_PAGE` üzerinde size `VERTICAL_LIST` ve diğer her yerde `GRID` verir; bu da, bir kayıt sayfasında nadiren istediğiniz davranıştır.
* Bir sekmenin içindeki her `widget`, bir [ön uç bileşeni](/l/tr/developers/extend/apps/layout/front-components), bir ilişki listesi veya diğer yerleşik widget türlerini oluşturabilir.
+* Bir `FRONT_COMPONENT` pencere öğesi, `headerCommandMenuItemUniversalIdentifiers` özelliğini aynı uygulamadaki komut menüsü öğelerinin evrensel tanımlayıcılarından oluşan sıralı bir diziye ayarlayabilir. Bu eylemler, pencere öğesi kart başlığında simge düğmeleri olarak görünür ve komut düzeyindeki kullanılabilirliklerini ve izin denetimlerini korur. Tanımlayıcılar benzersiz olmalı ve uygulama yüklendiğinde çözümlenebilmelidir.
* Sekmelerdeki `position`, sıralarını kontrol eder. Özel sekmeleri yerleşik olanların sonrasına yerleştirmek için daha yüksek değerler kullanın (ör. 50).
### Alan bileşenleri
@@ -136,8 +137,10 @@ export default definePageLayoutTab({
Her yerleşim girdisi ayrıca `tabs` ve bunların `widgets` ögelerini de açığa çıkarır, böylece herhangi bir düzeye başvurabilirsiniz:
```ts
- STANDARD_PAGE_LAYOUT_UNIVERSAL_IDENTIFIERS.taskRecordPage.tabs.home.universalIdentifier
- STANDARD_PAGE_LAYOUT_UNIVERSAL_IDENTIFIERS.taskRecordPage.tabs.home.widgets.fields.universalIdentifier
+ STANDARD_PAGE_LAYOUT_UNIVERSAL_IDENTIFIERS.taskRecordPage.tabs.home
+ .universalIdentifier;
+ STANDARD_PAGE_LAYOUT_UNIVERSAL_IDENTIFIERS.taskRecordPage.tabs.home.widgets
+ .fields.universalIdentifier;
```
Kısa bir takma ad `STANDARD_PAGE_LAYOUT` da kullanılabilir:
diff --git a/packages/twenty-docs/l/tr/developers/extend/apps/logic/background-jobs.mdx b/packages/twenty-docs/l/tr/developers/extend/apps/logic/background-jobs.mdx
index 25dd84a240a..48ddbfd23cc 100644
--- a/packages/twenty-docs/l/tr/developers/extend/apps/logic/background-jobs.mdx
+++ b/packages/twenty-docs/l/tr/developers/extend/apps/logic/background-jobs.mdx
@@ -6,45 +6,51 @@ icon: layer-group
Bir mantık fonksiyonu çalıştırması, `timeoutSeconds` değeriyle sınırlandırılır (en fazla 900 saniye). Bu sürede tamamlanamayan her şey — tam bir yeniden eşitleme, kayıt başına dağıtım, sizi hız sınırına takan üçüncü taraf bir API — daha küçük çalıştırmalara bölünmek zorundadır.
-`enqueueJob` tam olarak bunu yapar: Twenty işleyicilerinden, uygulamanızın mantık fonksiyonlarından birini daha sonra, kendi işleminde ve kendi zaman aşımı bütçesiyle çalıştırmasını ister. Çağıran hemen döner.
+`enqueueJobs` tam olarak bunu yapar: Twenty işleyicilerinden, uygulamanızın mantık fonksiyonlarından birini daha sonra, her veri yükü için bir kez, her çalıştırma kendi işleminde ve kendi zaman aşımı bütçesiyle çalıştırmasını ister. Çağıran hemen döner.
```text
- ┌─────────────────┐ enqueueJob(...) ┌──────────────┐ ┌────────────────────┐
+ ┌─────────────────┐ enqueueJobs(...) ┌──────────────┐ ┌────────────────────┐
│ Logic function │ ─────────────────▶ │ Job queue │──▶│ Logic function │
│ (returns now) │ │ (workers) │ │ (fresh run/timeout)│
└─────────────────┘ └──────────────┘ └────────────────────┘
```
-## Bir çalıştırmayı kuyruğa al
+## Çalıştırmaları kuyruğa al
-`enqueueJob` fonksiyonunu `twenty-sdk/logic-function` içinden içe aktarın ve çalıştırmak istediğiniz mantık fonksiyonunun `universalIdentifier` değerini işaret edin.
+`enqueueJobs` fonksiyonunu `twenty-sdk/logic-function` içinden içe aktarın, çalıştırılacak mantık fonksiyonunun `universalIdentifier` değerini belirtin ve kuyruğa almak üzere her çalıştırma için bir veri yükü iletin.
```ts src/logic-functions/sync-all-contacts.ts
-import { enqueueJob } from 'twenty-sdk/logic-function';
+import { enqueueJobs } from 'twenty-sdk/logic-function';
-await enqueueJob({
+await enqueueJobs({
logicFunctionUniversalIdentifier: '9f1c3d7e-51b8-4a29-8f0d-7c4e2a6b1d33',
- payload: { page: 1 },
+ payloads: [{ page: 1 }],
});
```
-Hedef fonksiyon, tıpkı diğer tetikleyicilerde olduğu gibi işleyici argümanı olarak `payload` alır. Çağrıyı yapanla **aynı uygulamaya** ait olmalıdır — başka bir uygulamanın fonksiyonunu kuyruğa alma girişimi `Logic function not found` hatasıyla reddedilir.
+Her çalıştırma, tıpkı diğer tetikleyicilerde olduğu gibi, veri yükünü işleyici argümanı olarak alır. Hedef, çağrıyı yapanla **aynı uygulamaya** ait olmalıdır — başka bir uygulamanın fonksiyonunu kuyruğa alma girişimi `Logic function not found` hatasıyla reddedilir ve hiçbir şey kuyruğa alınmaz. Tek bir çağrı en fazla `200` veri yükünü kabul eder.
<Note>
-`enqueueJob`, iş kabul edilir edilmez döner; işin çalışması bitince değil. Hedefin sonucunu döndürmez — çıktısını daha sonra okumak istiyorsanız, hedefin ürettiği veriyi [anahtar-değer deposuna](/l/tr/developers/extend/apps/logic/key-value-store) veya bir çalışma alanı kaydına yazmasını sağlayın.
+`enqueueJobs`, işler kabul edilir edilmez döner; işler çalıştığında değil. Hedeflerin sonuçlarını döndürmez — bunları daha sonra okumanız gerekiyorsa, her hedefin ürettiği veriyi [anahtar-değer deposuna](/l/tr/developers/extend/apps/logic/key-value-store) veya bir çalışma alanı kaydına yazmasını sağlayın.
+</Note>
+
+<Note>
+Her çağrıda tek bir işi kuyruğa alan eski `enqueueJob` yardımcısı kullanım dışı bırakılmıştır. Bunun yerine tek öğeli bir `payloads` listesiyle `enqueueJobs` kullanın.
</Note>
## İş seçenekleri
+Seçenekler, toplu işlemdeki her çalıştırma için geçerlidir.
+
| Seçenek | Varsayılan | Aralık | Ne yapar |
| ------------ | ---------- | ----------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `retryLimit` | `0` | `0`–`10` | Toplam ek kuyruk denemeleri. Uygulama tarafından istenen yeniden denemeler `3` ile sınırlandırılmıştır. Bunu yalnızca iki kez çalıştırılması güvenli olan işleyiciler için artırın. |
-| `delayMs` | `0` | `0`–`604800000` (7 gün) | Çalıştırma uygun hale gelmeden önce bu kadar süre bekleyin. |
+| `delayMs` | `0` | `0`–`604800000` (7 gün) | Çalıştırmalar uygun hale gelmeden önce bu kadar süre bekleyin. |
```ts
-await enqueueJob({
+await enqueueJobs({
logicFunctionUniversalIdentifier: '9f1c3d7e-51b8-4a29-8f0d-7c4e2a6b1d33',
- payload: { page: 1 },
+ payloads: [{ page: 1 }],
retryLimit: 3,
delayMs: 60_000,
});
@@ -96,7 +102,7 @@ Klasik biçim, bir sonraki imleçle *kendini* kuyruğa alan bir fonksiyondur. He
```ts src/logic-functions/sync-contacts-page.ts
import { defineLogicFunction } from 'twenty-sdk/define';
-import { enqueueJob } from 'twenty-sdk/logic-function';
+import { enqueueJobs } from 'twenty-sdk/logic-function';
const SYNC_CONTACTS_PAGE = '9f1c3d7e-51b8-4a29-8f0d-7c4e2a6b1d33';
@@ -106,9 +112,9 @@ const handler = async (params: { cursor?: string }) => {
await importContacts(contacts);
if (nextCursor) {
- await enqueueJob({
+ await enqueueJobs({
logicFunctionUniversalIdentifier: SYNC_CONTACTS_PAGE,
- payload: { cursor: nextCursor },
+ payloads: [{ cursor: nextCursor }],
delayMs: 2_000,
});
}
@@ -126,20 +132,16 @@ export default defineLogicFunction({
## Kayıt başına fan-out
-İş doğal olarak öğe bazındaysa, her öğe için bir iş kuyruğa alın ve döngüyü satır içi çalıştırmak yerine çalışanların bunları paralel olarak işlemesine izin verin.
+İş doğal olarak öğe bazındaysa, tek bir çağrıda her öğe için bir işi kuyruğa alın ve döngüyü satır içi çalıştırmak yerine çalışanların bunları paralel olarak işlemesine izin verin.
```ts
const companies = await listCompaniesToEnrich();
-await Promise.all(
- companies.map((company) =>
- enqueueJob({
- logicFunctionUniversalIdentifier: ENRICH_COMPANY,
- payload: { companyId: company.id },
- retryLimit: 2,
- }),
- ),
-);
+await enqueueJobs({
+ logicFunctionUniversalIdentifier: ENRICH_COMPANY,
+ payloads: companies.map((company) => ({ companyId: company.id })),
+ retryLimit: 2,
+});
```
## Uzun süre çalışan işler için iyi uygulamalar
@@ -150,7 +152,7 @@ Her şeyi tek seferde yapmaya çalışan bir çalıştırma, hata senaryosudur
```ts src/logic-functions/enrich-companies-batch.ts
import { defineLogicFunction } from 'twenty-sdk/define';
-import { enqueueJob, kv } from 'twenty-sdk/logic-function';
+import { enqueueJobs, kv } from 'twenty-sdk/logic-function';
const ENRICH_COMPANIES_BATCH = '3f9d1c02-8a44-4f0e-b1d7-9c2e5a7b4f10';
const CHUNK_SIZE = 50;
@@ -169,9 +171,9 @@ const handler = async (params: { offset?: number }) => {
await kv.set('enrich:progress', { offset: offset + companies.length });
if (companies.length === CHUNK_SIZE) {
- await enqueueJob({
+ await enqueueJobs({
logicFunctionUniversalIdentifier: ENRICH_COMPANIES_BATCH,
- payload: { offset: offset + CHUNK_SIZE },
+ payloads: [{ offset: offset + CHUNK_SIZE }],
});
}