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

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

@@ -0,0 +1,22 @@
+---
+title: Mejores prácticas
+---
+
+Este documento describe las mejores prácticas que debe seguir al trabajar en el backend.
+
+## Siga un enfoque modular
+
+El backend sigue un enfoque modular, que es un principio fundamental al trabajar con NestJS. Asegúrese de descomponer su código en módulos reutilizables para mantener una base de código limpia y organizada.
+Cada módulo debe encapsular una característica o funcionalidad particular y tener un alcance bien definido. Este enfoque modular permite una clara separación de responsabilidades y elimina complejidades innecesarias.
+
+## Exponer servicios para usar en módulos
+
+Siempre cree servicios que tengan una responsabilidad clara y única, lo que mejora la legibilidad y mantenibilidad del código. Nombre los servicios de manera descriptiva y consistente.
+
+También debe exponer servicios que desee usar en otros módulos. Exponer servicios a otros módulos es posible a través del poderoso sistema de inyección de dependencias de NestJS, y promueve un acoplamiento débil entre los componentes.
+
+## Evitar usar el tipo `any`
+
+Cuando declara una variable como `any`, el verificador de tipos de TypeScript no realiza ninguna comprobación de tipos, lo que hace posible asignar cualquier tipo de valores a la variable. TypeScript utiliza la inferencia de tipos para determinar el tipo de la variable a partir del valor. Al declararlo como `any`, TypeScript ya no puede inferir el tipo. Esto dificulta la captura de errores relacionados con el tipo durante el desarrollo, lo que lleva a errores en tiempo de ejecución y hace que el código sea menos mantenible, menos fiable y más difícil de entender para otros.
+
+Por eso todo debe tener un tipo. Entonces, si crea un nuevo objeto con un nombre y apellido, debe crear una interfaz o tipo que contenga un nombre y apellido y defina la forma del objeto que está manipulando.

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

@@ -0,0 +1,39 @@
+---
+title: Objetos personalizados
+---
+
+Los objetos son estructuras que te permiten almacenar datos (registros, atributos y valores) específicos de una organización. Twenty proporciona tanto objetos estándar como personalizados.
+
+Los objetos estándar son objetos incorporados con un conjunto de atributos disponibles para todos los usuarios. Ejemplos de objetos estándar en Twenty incluyen Empresa y Persona. Los objetos estándar tienen campos estándar que también están disponibles para todos los usuarios de Twenty, como Company.displayName.
+
+Los objetos personalizados son objetos que puedes crear para almacenar información que es única para tu organización. No están incorporados; los miembros de tu espacio de trabajo pueden crear y personalizar objetos personalizados para albergar información para la cual los objetos estándar no son aptos.
+
+## Esquema de alto nivel
+
+<div style={{textAlign: 'center'}}>
+    <img src="/images/docs/server/custom-object-schema.png" alt="Esquema de alto nivel" />
+</div>
+
+<br />
+
+## Cómo funciona
+
+Los objetos personalizados provienen de tablas de metadatos que determinan la forma, el nombre y el tipo de los objetos. Toda esta información está presente en la base de datos del esquema de metadatos, que consta de tablas:
+
+* **DataSource**: Detalles de dónde se encuentra la información.
+* **Object**: Describe el objeto y lo vincula a un DataSource.
+* **Field**: Describe los campos de un objeto y lo conecta al objeto.
+
+Para añadir un objeto personalizado, el workspaceMember consultará la API de /metadata. Esto actualiza los metadatos de acuerdo y calcula un esquema GraphQL basado en los metadatos, almacenándolo en un caché de GQL para su uso posterior.
+
+<div style={{textAlign: 'center'}}>
+    <img src="/images/docs/server/add-custom-objects.jpeg" alt="Consultando la API de /metadata para añadir objetos personalizados" />
+</div>
+
+<br />
+
+Para obtener datos, el proceso implica hacer consultas a través del endpoint /graphql y pasarlos a través del Query Resolver.
+
+<div style={{textAlign: 'center'}}>
+    <img src="/images/docs/server/custom-object-schema.png" alt="Consulta el endpoint /graphql para obtener datos" />
+</div>

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

@@ -0,0 +1,46 @@
+---
+title: Indicadores de característica
+---
+
+Los indicadores de característica se usan para ocultar características experimentales. Para Twenty, se configuran a nivel de espacio de trabajo y no a nivel de usuario.
+
+## Agregar un nuevo indicador de característica
+
+En `FeatureFlagKey.ts` agrega el indicador de característica:
+
+```ts
+type FeatureFlagKey =
+  | 'IS_FEATURENAME_ENABLED'
+  | ...;
+```
+
+También agrégalo al enum en `feature-flag.entity.ts`:
+
+```ts
+enum FeatureFlagKeys {
+    IsFeatureNameEnabled = 'IS_FEATURENAME_ENABLED',
+    ...
+}
+```
+
+Para aplicar un indicador de característica en una característica de **backend** usa:
+
+```ts
+@Gate({
+  featureFlag: 'IS_FEATURENAME_ENABLED',
+})
+```
+
+Para aplicar un indicador de característica en una característica de **frontend** usa:
+
+```ts
+const isFeatureNameEnabled = useIsFeatureEnabled('IS_FEATURENAME_ENABLED');
+```
+
+## Configurar indicadores de característica para el despliegue
+
+Cambie el registro correspondiente en la Tabla `core.featureFlag`:
+
+| iD        | clave                    | workspaceId               | valor       |
+| --------- | ------------------------ | ------------------------- | ----------- |
+| Aleatorio | `IS_FEATURENAME_ENABLED` | ID del espacio de trabajo | `verdadero` |

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

@@ -0,0 +1,125 @@
+---
+title: Arquitectura de Carpetas
+info: Una mirada detallada a la arquitectura de carpetas de nuestro servidor
+---
+
+La estructura del directorio backend es la siguiente:
+
+```
+server
+  └───ability
+  └───constants
+  └───core
+  └───database
+  └───decorators
+  └───filters
+  └───guards
+  └───health
+  └───integrations
+  └───metadata
+  └───workspace
+  └───utils
+```
+
+## Habilidad
+
+Define permisos e incluye gestores para cada entidad.
+
+## Decoradores
+
+Define decoradores personalizados en NestJS para funcionalidad adicional.
+
+Ver [decoradores personalizados](https://docs.nestjs.com/custom-decorators) para más detalles.
+
+## Filtros
+
+Incluye filtros de excepciones para manejar excepciones que puedan ocurrir en endpoints de GraphQL.
+
+## Guardias
+
+Ver [guardias](https://docs.nestjs.com/guards) para más detalles.
+
+## Salud
+
+Incluye una API REST públicamente disponible (healthz) que devuelve un JSON para confirmar si la base de datos está funcionando como se esperaba.
+
+## Metadatos
+
+Define objetos personalizados y hace disponible una API de GraphQL (graphql/metadata).
+
+## Espacio de trabajo
+
+Genera y sirve un esquema GraphQL personalizado basado en los metadatos.
+
+### Estructura del Directorio de Espacio de Trabajo
+
+```
+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 raíz del directorio de espacio de trabajo incluye el `espacio.trabajo.factory.ts`, un archivo que contiene la función `createGraphQLSchema`. Esta función genera un esquema específico para el espacio de trabajo utilizando los metadatos para adaptar un esquema para espacios de trabajo individuales. Al separar la construcción del esquema y del resolver, usamos la función `makeExecutableSchema`, que combina estos elementos discretos.
+
+Esta estrategia no solo se trata de organización, sino que también ayuda con la optimización, como el almacenamiento en caché de definiciones de tipos generados para mejorar el rendimiento y la escalabilidad.
+
+### Constructor de Esquema de Espacio de Trabajo
+
+Genera el esquema GraphQL, e incluye:
+
+#### Fábricas:
+
+Constructores especializados para generar constructos relacionados con GraphQL.
+
+* La fábrica de tipos traduce los metadatos de los campos en tipos GraphQL utilizando `TypeMapperService`.
+* La fábrica de definiciones de tipos crea objetos de entrada o salida de GraphQL derivados de `objectMetadata`.
+
+#### Tipos GraphQL
+
+Incluye enumeraciones, entradas, objetos y escalares, y sirve como bloques de construcción para la construcción del esquema.
+
+#### Interfaces y Definiciones de Objetos
+
+Contiene los planos para entidades GraphQL, e incluye tanto tipos predefinidos como personalizados como `MONEY` o `URL`.
+
+#### Servicios
+
+Contiene el servicio responsable de asociar FieldMetadataType con su escalar de GraphQL apropiado o modificadores de consulta.
+
+#### Almacenamiento
+
+Incluye la clase `TypeDefinitionsStorage` que contiene definiciones de tipos reutilizables, previniendo duplicación de tipos GraphQL.
+
+### Constructor de Resolver de Espacio de Trabajo
+
+Crea funciones de resolutor para consultar y modificar el esquema GraphQL.
+
+Cada fábrica en este directorio es responsable de producir un tipo de resolutor distinto, como el `FindManyResolverFactory`, diseñado para aplicación adaptable a través de varias tablas.
+
+### Ejecutor de Consultas de Espacio de Trabajo
+
+Ejecuta las consultas generadas en la base de datos y analiza el resultado.

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

@@ -0,0 +1,41 @@
+---
+title: Cola de Mensajes
+---
+
+Las colas facilitan la realización de operaciones asíncronas. Se pueden utilizar para realizar tareas en segundo plano, como enviar un correo de bienvenida al registrarse.
+Cada caso de uso tendrá su propia clase de cola extendida de `MessageQueueServiceBase`.
+
+Actualmente, solo soportamos `bull-mq`[bull-mq](https://bullmq.io/) como el controlador de cola.
+
+## Pasos para crear y usar una nueva cola
+
+1. Agregue un nombre de cola para su nueva cola en la enumeración `MESSAGE_QUEUES`.
+2. Proporcione la implementación de fábrica de la cola con el nombre de la cola como el token de dependencia.
+3. Inyecte la cola que creó en el módulo/servicio requerido con el nombre de la cola como el token de dependencia.
+4. Agregue una clase de trabajador con inyección basada en token, al igual que el productor.
+
+### Ejemplo de uso
+
+```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/es/developers/contribute/capabilities/backend-development/server-commands.mdx

@@ -0,0 +1,87 @@
+---
+title: Comandos de Backend
+icon: terminal
+---
+
+## Comandos útiles
+
+Estos comandos deben ejecutarse desde la carpeta packages/twenty-server.
+Desde cualquier otra carpeta, puedes ejecutar `npx nx {command} twenty-server` (o `npx nx run twenty-server:{command}`).
+
+### Configuración inicial
+
+```
+npx nx database:reset twenty-server # setup the database with dev seeds
+```
+
+### Iniciando el servidor
+
+```
+npx nx run twenty-server:start
+```
+
+### Lint
+
+```
+npx nx run twenty-server:lint # pass --fix to fix lint errors
+```
+
+### Prueba
+
+```
+npx nx run twenty-server:test:unit          # run unit tests
+npx nx run twenty-server:test:integration   # run integration tests
+```
+
+Nota: puedes ejecutar `npx nx run twenty-server:test:integration:with-db-reset` en caso de que necesites restablecer la base de datos antes de ejecutar las pruebas de integración.
+
+### Restablecer la base de datos
+
+Si deseas restablecer y sembrar la base de datos, puedes ejecutar el siguiente comando:
+
+```bash
+npx nx run twenty-server:database:reset
+```
+
+### Migraciones
+
+#### Para objetos en esquemas Core/Metadata (TypeORM)
+
+```bash
+npx nx run twenty-server:database:migrate:generate
+```
+
+## Stack Tecnológico
+
+Twenty utiliza principalmente NestJS para el backend.
+
+Prisma fue el primer ORM que usamos. Pero para permitir a los usuarios crear campos y objetos personalizados, un nivel más bajo tenía más sentido ya que necesitamos tener un control detallado. El proyecto ahora usa TypeORM.
+
+Así es como se ve la pila tecnológica ahora.
+
+**Core**
+
+* [NestJS](https://nestjs.com/)
+* [TypeORM](https://typeorm.io/)
+* [GraphQL Yoga](https://the-guild.dev/graphql/yoga-server)
+
+**Base de datos**
+
+* [Postgres](https://www.postgresql.org/)
+
+**Integraciones de terceros**
+
+* [Sentry](https://sentry.io/welcome/) para rastrear errores
+
+**Pruebas**
+
+* [Jest](https://jestjs.io/)
+
+**Herramientas**
+
+* [Yarn](https://yarnpkg.com/)
+* [Oxlint](https://oxc.rs/docs/guide/usage/linter.html)
+
+**Desarrollo**
+
+* [AWS EKS](https://aws.amazon.com/eks/)

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

@@ -0,0 +1,85 @@
+---
+title: Aplicación Zapier
+---
+
+Sincroniza sin esfuerzo Twenty con más de 3000 aplicaciones usando [Zapier](https://zapier.com/). ¡Automatiza tareas, mejora la productividad y potencia tus relaciones con los clientes!
+
+## Acerca de Zapier
+
+Zapier es una herramienta que permite automatizar flujos de trabajo al conectar las aplicaciones que tu equipo utiliza a diario. El concepto fundamental de Zapier son los flujos de trabajo automatizados, llamados Zaps, que incluyen desencadenantes y acciones.
+
+Puedes aprender más sobre cómo funciona Zapier [aquí](https://zapier.com/how-it-works).
+
+## Configuración
+
+### Paso 1: Instalar paquetes de Zapier
+
+```bash
+cd packages/twenty-zapier
+
+yarn
+```
+
+### Paso 2: Iniciar sesión con la CLI
+
+Utiliza tus credenciales de Zapier para iniciar sesión usando la CLI:
+
+```bash
+zapier login
+```
+
+### Paso 3: Configurar variables de entorno
+
+Desde la carpeta `packages/twenty-zapier`, ejecuta:
+
+```bash
+cp .env.example .env
+```
+
+Ejecuta la aplicación localmente, ve a [http://localhost:3000/settings/api-webhooks](http://localhost:3000/settings/api-webhooks) y genera una clave API.
+
+Reemplaza el valor de **YOUR_API_KEY** en el archivo `.env` con la clave API que acabas de generar.
+
+## Desarrollo
+
+<Warning>
+
+Asegúrate de ejecutar `yarn build` antes de cualquier comando `zapier`.
+
+</Warning>
+
+### Prueba
+
+```bash
+yarn test
+```
+
+### Lint
+
+```bash
+yarn format
+```
+
+### Observa y compila mientras editas el código
+
+```bash
+yarn watch
+```
+
+### Valida tu aplicación Zapier
+
+```bash
+yarn validate
+```
+
+### Despliega tu aplicación Zapier
+
+```bash
+yarn deploy
+```
+
+### Lista todos los comandos de Zapier CLI
+
+```bash
+zapier
+```