i18n - docs translations (#20764)

Created by Github action Co-authored-by: github-actions <github-actions@twenty.com>
2026-05-20 13:21:44 +02:00
parent 00fad657f4
commit fb47e4497a
6 changed files with 678 additions and 24 deletions
@@ -13,8 +13,8 @@ Fiecare fișier de funcție folosește `defineLogicFunction()` pentru a exporta

 ```ts src/logic-functions/createPostCard.logic-function.ts
 import { defineLogicFunction } from 'twenty-sdk/define';
-import type { DatabaseEventPayload, ObjectRecordCreateEvent, CronPayload, RoutePayload } from 'twenty-sdk/define';
-import { CoreApiClient, type Person } from 'twenty-client-sdk/core';
+import type { RoutePayload } from 'twenty-sdk/logic-function';
+import { CoreApiClient } from 'twenty-client-sdk/core';

 const handler = async (params: RoutePayload) => {
  const client = new CoreApiClient();
@@ -79,10 +79,10 @@ yarn twenty logs

 Când un declanșator de rută invocă funcția logică, aceasta primește un obiect `RoutePayload` care urmează
 [AWS HTTP API v2 format](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-integrations-lambda.html).
-Importați tipul `RoutePayload` din `twenty-sdk`:
+Importați tipul `RoutePayload` din `twenty-sdk/logic-function`:

 ```ts
-import { defineLogicFunction, type RoutePayload } from 'twenty-sdk/define';
+import type { RoutePayload } from 'twenty-sdk/logic-function';

 const handler = async (event: RoutePayload) => {
  const { headers, queryStringParameters, pathParameters, body } = event;
@@ -141,6 +141,115 @@ const handler = async (event: RoutePayload) => {
 Numele anteturilor sunt normalizate la litere mici. Accesați-le folosind chei cu litere mici (de exemplu, `event.headers['content-type']`).
 </Note>

+#### Payload-ul declanșatorului de eveniment al bazei de date
+
+Când un declanșator de eveniment al bazei de date apelează funcția dvs. logică, aceasta primește un `DatabaseEventPayload` pentru fiecare înregistrare modificată. Payload-ul combină metadatele despre spațiul de lucru și obiectul sursă cu evenimentul la nivel de înregistrare.
+
+```ts
+import type {
+  DatabaseEventPayload,
+  ObjectRecordCreateEvent,
+  ObjectRecordDestroyEvent,
+  ObjectRecordUpdateEvent,
+} from 'twenty-sdk/logic-function';
+
+type Person = {
+  id: string;
+  emails?: { primaryEmail?: string };
+};
+```
+
+Payload-ul include:
+
+| Proprietate                                      | Descriere                                                                                                      |
+| ------------------------------------------------ | -------------------------------------------------------------------------------------------------------------- |
+| `name`                                           | Numele evenimentului, cum ar fi `person.updated`.                                                              |
+| `workspaceId`                                    | Spațiul de lucru în care a avut loc evenimentul.                                                               |
+| `objectMetadata`                                 | Metadate pentru obiectul care s-a modificat.                                                                   |
+| `recordId`                                       | ID-ul înregistrării modificate.                                                                                |
+| `userId`, `userWorkspaceId`, `workspaceMemberId` | Câmpurile actorului atunci când evenimentul a fost cauzat de un utilizator al spațiului de lucru.              |
+| `properties`                                     | Datele înregistrării pentru eveniment, cu `before`, `after`, `diff` și `updatedFields` în funcție de operație. |
+
+| Eveniment          | Datele înregistrării                                                                                           |
+| ------------------ | -------------------------------------------------------------------------------------------------------------- |
+| `person.created`   | `event.properties.after`                                                                                       |
+| `person.updated`   | `event.properties.before`, `event.properties.after`, `event.properties.diff`, `event.properties.updatedFields` |
+| `person.destroyed` | `event.properties.before`                                                                                      |
+
+Pentru ștergeri logice (soft delete), `.deleted` urmează structura de tip update deoarece câmpul `deletedAt` al înregistrării se modifică.
+Pentru ștergeri permanente, folosiți `.destroyed`.
+
+<Note>
+`databaseEventTriggerSettings.updatedFields` filtrează ce evenimente de actualizare declanșează funcția.
+`event.properties.updatedFields` vă indică ce câmpuri s-au modificat efectiv în evenimentul curent.
+</Note>
+
+Exemplu de eveniment de creare:
+
+```ts
+type PersonCreatedEvent = DatabaseEventPayload<
+  ObjectRecordCreateEvent<Person>
+>;
+
+const handler = async (event: PersonCreatedEvent) => {
+  const person = event.properties.after;
+
+  return {
+    personId: event.recordId,
+    email: person.emails?.primaryEmail,
+  };
+};
+```
+
+Exemplu de eveniment de actualizare:
+
+```ts
+type PersonUpdatedEvent = DatabaseEventPayload<
+  ObjectRecordUpdateEvent<Person>
+>;
+
+const handler = async (event: PersonUpdatedEvent) => {
+  const { before, after, diff, updatedFields } = event.properties;
+
+  return {
+    personId: event.recordId,
+    updatedFields,
+    previousEmail: before.emails?.primaryEmail,
+    currentEmail: after.emails?.primaryEmail,
+    emailDiff: diff.emails,
+  };
+};
+```
+
+Declanșare doar la actualizări ale e-mailului:
+
+```ts
+export default defineLogicFunction({
+  ...,
+  databaseEventTriggerSettings: {
+    eventName: 'person.updated',
+    updatedFields: ['emails'],
+  },
+});
+```
+
+Exemplu de eveniment de ștergere:
+
+```ts
+type PersonDestroyedEvent = DatabaseEventPayload<
+  ObjectRecordDestroyEvent<Person>
+>;
+
+const handler = async (event: PersonDestroyedEvent) => {
+  const personBeforeDestroy = event.properties.before;
+
+  return {
+    personId: event.recordId,
+    email: personBeforeDestroy.emails?.primaryEmail,
+  };
+};
+```
+
 #### Expunerea unei funcții ca instrument AI sau ca acțiune în fluxul de lucru

 Funcțiile logice pot fi expuse în două locuri, fiecare cu propriul declanșator: