snapshot of https://github.com/twentyhq/twenty.git (main, 2026-09-17; blobs > 131072B omitted)

packages/twenty-docs/l/it/developers/contribute/capabilities/backend-development/best-practices-server.mdx

@@ -0,0 +1,22 @@
+---
+title: Migliori Pratiche
+---
+
+Questo documento descrive le migliori pratiche da seguire quando si lavora sul backend.
+
+## Segui un approccio modulare
+
+Il backend segue un approccio modulare, che è un principio fondamentale quando si lavora con NestJS. Assicurati di suddividere il tuo codice in moduli riutilizzabili per mantenere una codebase pulita e organizzata.
+Ogni modulo dovrebbe incapsulare una particolare caratteristica o funzionalità e avere un ambito ben definito. Questo approccio modulare consente una chiara separazione delle responsabilità e rimuove complessità non necessarie.
+
+## Esporre servizi da usare nei moduli
+
+Crea sempre servizi che abbiano una responsabilità chiara e singola, migliorando la leggibilità e la manutenzione del codice. Dai ai servizi nomi descrittivi e coerenti.
+
+Dovresti anche esporre i servizi che vuoi utilizzare in altri moduli. Esporre servizi ad altri moduli è possibile tramite il potente sistema di iniezione delle dipendenze di NestJS e promuove un basso accoppiamento tra i componenti.
+
+## Evitare di usare il tipo `any`
+
+Quando dichiari una variabile come `any`, il sistema di controllo dei tipi di TypeScript non esegue alcun controllo dei tipi, rendendo possibile assegnare alla variabile valori di qualsiasi tipo. TypeScript utilizza l'inferenza dei tipi per determinare il tipo della variabile in base al valore. Dichiarandola come `any`, TypeScript non può più dedurre il tipo. Questo rende difficile individuare errori legati ai tipi durante lo sviluppo, portando a errori in fase di esecuzione e rendendo il codice meno manutenibile, meno affidabile e più difficile da comprendere per gli altri.
+
+È per questo che tutto dovrebbe avere un tipo. Quindi, se crei un nuovo oggetto con un nome e un cognome, dovresti creare un'interfaccia o un tipo che contenga un nome e un cognome e che definisca la struttura dell'oggetto che stai manipolando.

packages/twenty-docs/l/it/developers/contribute/capabilities/backend-development/custom-objects.mdx

@@ -0,0 +1,39 @@
+---
+title: Oggetti personalizzati
+---
+
+Gli oggetti sono strutture che permettono di memorizzare dati (record, attributi e valori) specifici di un'organizzazione. Twenty offre sia oggetti standard che personalizzati.
+
+Gli oggetti standard sono oggetti integrati con un set di attributi disponibili per tutti gli utenti. Esempi di oggetti standard in Twenty includono Company e Person. Gli oggetti standard hanno campi standard che sono inoltre disponibili per tutti gli utenti di Twenty, come Company.displayName.
+
+Gli oggetti personalizzati sono oggetti che puoi creare per memorizzare informazioni uniche per la tua organizzazione. Non sono integrati; i membri del tuo workspace possono creare e personalizzare oggetti personalizzati per contenere informazioni non adatte per gli oggetti standard.
+
+## Schema di alto livello
+
+<div style={{textAlign: 'center'}}>
+    <img src="/images/docs/server/custom-object-schema.png" alt="Schema di alto livello" />
+</div>
+
+<br />
+
+## Come funziona
+
+Gli oggetti personalizzati derivano da tabelle di metadati che determinano la forma, il nome e il tipo degli oggetti. Tutte queste informazioni sono presenti nello schema di metadati, composto da tabelle:
+
+* **DataSource**: Dettagli su dove sono presenti i dati.
+* **Oggetto**: Descrive l'oggetto e si collega a una DataSource.
+* **Campo**: Delinea i campi di un Oggetto e si collega all'Oggetto.
+
+Per aggiungere un oggetto personalizzato, il membro del workspace interrogherà l'API /metadata. Questo aggiorna i metadati di conseguenza e calcola uno schema GraphQL basato sui metadati, memorizzandolo in una cache GQL per un uso successivo.
+
+<div style={{textAlign: 'center'}}>
+    <img src="/images/docs/server/add-custom-objects.jpeg" alt="Interroga l'API /metadata per aggiungere oggetti personalizzati" />
+</div>
+
+<br />
+
+Per recuperare i dati, il processo consiste nel effettuare interrogazioni tramite l'endpoint /graphql e passarle tramite il Query Resolver.
+
+<div style={{textAlign: 'center'}}>
+    <img src="/images/docs/server/custom-object-schema.png" alt="Interroga l'endpoint /graphql per recuperare dati" />
+</div>

packages/twenty-docs/l/it/developers/contribute/capabilities/backend-development/feature-flags.mdx

@@ -0,0 +1,46 @@
+---
+title: Flag delle funzionalità
+---
+
+I flag delle funzionalità vengono utilizzati per nascondere funzionalità sperimentali. Per Twenty, sono impostati a livello di workspace e non a livello utente.
+
+## Aggiunta di un nuovo flag delle funzionalità
+
+In `FeatureFlagKey.ts` aggiungi il flag di funzionalità:
+
+```ts
+type FeatureFlagKey =
+  | 'IS_FEATURENAME_ENABLED'
+  | ...;
+```
+
+Aggiungilo anche all'enum in `feature-flag.entity.ts`:
+
+```ts
+enum FeatureFlagKeys {
+    IsFeatureNameEnabled = 'IS_FEATURENAME_ENABLED',
+    ...
+}
+```
+
+Per applicare un flag di funzionalità su una funzione **backend** usa:
+
+```ts
+@Gate({
+  featureFlag: 'IS_FEATURENAME_ENABLED',
+})
+```
+
+Per applicare un flag di funzionalità su una funzione **frontend** usa:
+
+```ts
+const isFeatureNameEnabled = useIsFeatureEnabled('IS_FEATURENAME_ENABLED');
+```
+
+## Configura i flag delle funzionalità per il deployment
+
+Cambia il record corrispondente nella Tabella `core.featureFlag`:
+
+| id      | chiave                   | workspaceId | valore |
+| ------- | ------------------------ | ----------- | ------ |
+| Casuale | `IS_FEATURENAME_ENABLED` | IDWorkspace | `vero` |

packages/twenty-docs/l/it/developers/contribute/capabilities/backend-development/folder-architecture-server.mdx

@@ -0,0 +1,125 @@
+---
+title: Architettura delle Cartelle
+info: Uno sguardo dettagliato alla nostra architettura di cartelle del server
+---
+
+La struttura della directory del backend è la seguente:
+
+```
+server
+  └───ability
+  └───constants
+  └───core
+  └───database
+  └───decorators
+  └───filters
+  └───guards
+  └───health
+  └───integrations
+  └───metadata
+  └───workspace
+  └───utils
+```
+
+## Capacità
+
+Definisce le autorizzazioni e include gestori per ciascuna entità.
+
+## Decoratori
+
+Definisce decoratori personalizzati in NestJS per funzionalità aggiuntive.
+
+Vedi [decoratori personalizzati](https://docs.nestjs.com/custom-decorators) per maggiori dettagli.
+
+## Filtri
+
+Include filtri di eccezione per gestire le eccezioni che potrebbero verificarsi nei punti finali GraphQL.
+
+## Guards
+
+Vedi [guards](https://docs.nestjs.com/guards) per ulteriori dettagli.
+
+## Stato di salute
+
+Include un'API REST pubblicamente disponibile (healthz) che restituisce un JSON per confermare se il database funziona correttamente.
+
+## Metadati
+
+Definisce oggetti personalizzati e rende disponibile un'API GraphQL (graphql/metadata).
+
+## Workspace
+
+Genera e serve schemi GraphQL personalizzati basati sui metadati.
+
+### Struttura della directory dello spazio di lavoro
+
+```
+workspace
+
+  └───workspace-schema-builder
+    └───factories
+    └───graphql-types
+    └───database
+    └───interfaces
+    └───object-definitions
+    └───services
+    └───storage
+    └───utils
+  └───workspace-resolver-builder
+    └───factories
+    └───interfaces
+  └───workspace-query-builder
+    └───factories
+    └───interfaces
+  └───workspace-query-runner
+    └───interfaces
+    └───utils
+  └───workspace-datasource
+  └───workspace-manager
+  └───workspace-migration-runner
+  └───utils
+  └───workspace.module.ts
+  └───workspace.factory.spec.ts
+  └───workspace.factory.ts
+```
+
+La radice della directory di lavoro include il `workspace.factory.ts`, un file contenente la funzione `createGraphQLSchema`. Questa funzione genera uno schema specifico per il workspace utilizzando i metadati per adattare uno schema per i singoli lavori. Separando la costruzione dello schema e del risolutore, utilizziamo la funzione `makeExecutableSchema`, che combina questi elementi discreti.
+
+Questa strategia non riguarda solo l'organizzazione, ma aiuta anche con l'ottimizzazione, come la memorizzazione nella cache delle definizioni di tipo generate per migliorare le prestazioni e la scalabilità.
+
+### Generatore dello schema dello spazio di lavoro
+
+Genera lo schema GraphQL e include:
+
+#### Factory:
+
+Costruttori specializzati per generare costrutti correlati a GraphQL.
+
+* La fabbrica type.factory traduce i metadati del campo in tipi GraphQL utilizzando `TypeMapperService`.
+* La fabbrica type-definition.factory crea oggetti di input o output GraphQL derivati da `objectMetadata`.
+
+#### Tipi GraphQL
+
+Include enumerazioni, input, oggetti e scalari e funge da base per la costruzione dello schema.
+
+#### Interfacce e Definizioni di Oggetti
+
+Contiene i progetti per le entità GraphQL e include tipi predefiniti e personalizzati come `MONEY` o `URL`.
+
+#### Servizi
+
+Contiene il servizio responsabile dell'associazione di FieldMetadataType al relativo scalare GraphQL o ai modificatori di query.
+
+#### Archiviazione
+
+Include la classe `TypeDefinitionsStorage` che contiene definizioni di tipo riutilizzabili, evitando la duplicazione di tipi GraphQL.
+
+### Generatore di resolver dello spazio di lavoro
+
+Crea funzioni di risolutore per interrogare e modificare lo schema GraphQL.
+
+Ogni factory in questa directory è responsabile della produzione di un tipo di resolver distinto, come `FindManyResolverFactory`, progettato per un'applicazione adattabile su varie tabelle.
+
+### Esecutore di query dello spazio di lavoro
+
+Esegue le query generate sul database e analizza il risultato.

packages/twenty-docs/l/it/developers/contribute/capabilities/backend-development/queue.mdx

@@ -0,0 +1,41 @@
+---
+title: Coda di messaggi
+---
+
+Le code facilitano l'esecuzione di operazioni asincrone. Possono essere usate per eseguire attività in background come l'invio di un'email di benvenuto alla registrazione.
+Ogni caso d'uso avrà la propria classe di coda estesa da `MessageQueueServiceBase`.
+
+Al momento supportiamo solo `bull-mq`[bull-mq](https://bullmq.io/) come driver della coda.
+
+## Passaggi per creare e utilizzare una nuova coda
+
+1. Aggiungi un nome di coda per la tua nuova coda sotto l'enum `MESSAGE_QUEUES`.
+2. Fornire l'implementazione della fabbrica della coda con il nome della coda come token di dipendenza.
+3. Inserisci la coda che hai creato nel modulo/servizio richiesto con il nome della coda come token di dipendenza.
+4. Aggiungi una classe worker con iniezione basata su token, proprio come il produttore.
+
+### Esempio di utilizzo
+
+```ts
+class Resolver {
+  constructor(@Inject(MESSAGE_QUEUES.custom) private queue: MessageQueueService) {}
+
+  async onSomeAction() {
+    //business logic
+    await this.queue.add(someData);
+  }
+}
+
+//async worker
+class CustomWorker {
+  constructor(@Inject(MESSAGE_QUEUES.custom) private queue: MessageQueueService) {
+    this.initWorker();
+  }
+
+  async initWorker() {
+    await this.queue.work(async ({ id, data }) => {
+      //worker logic
+    });
+  }
+}
+```

packages/twenty-docs/l/it/developers/contribute/capabilities/backend-development/server-commands.mdx

@@ -0,0 +1,87 @@
+---
+title: Comandi Backend
+icon: terminal
+---
+
+## Comandi utili
+
+Questi comandi devono essere eseguiti dalla cartella packages/twenty-server.
+Da qualsiasi altra cartella puoi eseguire `npx nx {command} twenty-server` (oppure `npx nx run twenty-server:{command}`).
+
+### Impostazione iniziale
+
+```
+npx nx database:reset twenty-server # setup the database with dev seeds
+```
+
+### Avvio del server
+
+```
+npx nx run twenty-server:start
+```
+
+### Lint
+
+```
+npx nx run twenty-server:lint # pass --fix to fix lint errors
+```
+
+### Test
+
+```
+npx nx run twenty-server:test:unit          # run unit tests
+npx nx run twenty-server:test:integration   # run integration tests
+```
+
+Nota: puoi eseguire `npx nx run twenty-server:test:integration:with-db-reset` nel caso in cui sia necessario resettare il database prima di eseguire i test di integrazione.
+
+### Ripristino del database
+
+Se vuoi resettare e seminare il database, puoi eseguire il seguente comando:
+
+```bash
+npx nx run twenty-server:database:reset
+```
+
+### Migrazioni
+
+#### Per oggetti negli schemi Core/Metadata (TypeORM)
+
+```bash
+npx nx run twenty-server:database:migrate:generate
+```
+
+## Tech Stack
+
+Twenty utilizza principalmente NestJS per il backend.
+
+Prisma è stato il primo ORM che abbiamo usato. Ma per permettere agli utenti di creare campi personalizzati e oggetti personalizzati, un livello più basso aveva più senso poiché abbiamo bisogno di avere un controllo granulare. Il progetto ora utilizza TypeORM.
+
+Ecco come appare ora lo stack tecnologico.
+
+**Core**
+
+* [NestJS](https://nestjs.com/)
+* [TypeORM](https://typeorm.io/)
+* [GraphQL Yoga](https://the-guild.dev/graphql/yoga-server)
+
+**Database**
+
+* [Postgres](https://www.postgresql.org/)
+
+**Integrazioni di terze parti**
+
+* [Sentry](https://sentry.io/welcome/) per il tracciamento degli errori
+
+**Testing**
+
+* [Jest](https://jestjs.io/)
+
+**Strumenti**
+
+* [Yarn](https://yarnpkg.com/)
+* [Oxlint](https://oxc.rs/docs/guide/usage/linter.html)
+
+**Sviluppo**
+
+* [AWS EKS](https://aws.amazon.com/eks/)

packages/twenty-docs/l/it/developers/contribute/capabilities/backend-development/zapier.mdx

@@ -0,0 +1,85 @@
+---
+title: App di Zapier
+---
+
+Sincronizza facilmente Twenty con oltre 3000 app utilizzando [Zapier](https://zapier.com/). Automatizza le attività, aumenta la produttività e potenzia le relazioni con i clienti!
+
+## Informazioni su Zapier
+
+Zapier è uno strumento che ti permette di automatizzare i flussi di lavoro collegando le app che il tuo team usa quotidianamente. Il concetto fondamentale di Zapier sono i flussi di lavoro automatici, chiamati Zaps, che includono trigger e azioni.
+
+Puoi saperne di più su come funziona Zapier [qui](https://zapier.com/how-it-works).
+
+## Impostazione
+
+### Passo 1: Installa i pacchetti di Zapier
+
+```bash
+cd packages/twenty-zapier
+
+yarn
+```
+
+### Passaggio 2: Accedi con la CLI
+
+Usa le tue credenziali Zapier per accedere usando il CLI:
+
+```bash
+zapier login
+```
+
+### Passaggio 3: Configura le variabili d'ambiente
+
+Dalla cartella `packages/twenty-zapier`, esegui:
+
+```bash
+cp .env.example .env
+```
+
+Esegui l'applicazione localmente, vai su [http://localhost:3000/settings/api-webhooks](http://localhost:3000/settings/api-webhooks) e genera una chiave API.
+
+Sostituisci il valore **YOUR_API_KEY** nel file `.env` con la chiave API appena generata.
+
+## Sviluppo
+
+<Warning>
+
+Assicurati di eseguire `yarn build` prima di qualsiasi comando `zapier`.
+
+</Warning>
+
+### Test
+
+```bash
+yarn test
+```
+
+### Lint
+
+```bash
+yarn format
+```
+
+### Osserva e compila mentre modifichi il codice
+
+```bash
+yarn watch
+```
+
+### Convalida la tua app Zapier
+
+```bash
+yarn validate
+```
+
+### Distribuisci la tua app Zapier
+
+```bash
+yarn deploy
+```
+
+### Elenca tutti i comandi del CLI di Zapier
+
+```bash
+zapier
+```