¿Qué son los Monorepos?

Imagina que tienes una caja de rompecabezas donde todas las piezas de todos tus rompecabezas están mezcladas. Eso sería un caos, ¿verdad? Ahora imagina lo contrario: todas las piezas de un solo rompecabezas bien organizadas en su propia caja. Eso es más fácil de manejar.

Un monorepo es como tener todas las piezas de tu proyecto de software (aplicaciones web, aplicaciones móviles, librerías compartidas, utilidades) organizadas en una sola "caja" o repositorio. En lugar de tener múltiples repositorios dispersos, todo vive en un solo lugar.

💡 Concepto clave: Un monorepo es un repositorio único que contiene múltiples proyectos relacionados, permitiendo compartir código, dependencias y herramientas de forma centralizada.

¿Por qué usar Monorepos?

La analogía del rompecabezas

Imagina que tienes una aplicación de e-commerce que consiste en:

✅ Con monorepos: Todo esto vive en un solo lugar, puedes hacer cambios que afecten múltiples partes del proyecto de forma coordinada, y mantener la coherencia es mucho más fácil.

Conceptos Fundamentales

Workspaces (Espacios de Trabajo)

Los workspaces son como "divisiones lógicas" dentro de tu monorepo. Cada workspace representa un proyecto independiente (una aplicación, una librería, etc.) pero que puede compartir dependencias con otros workspaces.

📱 Apps

Aplicaciones ejecutables como apps web, apps móviles, APIs, etc.

📦 Packages

Librerías y componentes reutilizables que pueden ser consumidos por las apps.

⚙️ Configs

Configuraciones compartidas como ESLint, TypeScript, Babel, etc.

Gestión de Dependencias

En lugar de tener archivos package.json independientes en cada proyecto, el monorepo tiene un package.json principal que define los workspaces y scripts globales.

package.json del monorepo raíz
// Configuración del monorepo raíz
{
  "name": "mi-monorepo",
  "private": true,
  // Define qué carpetas son workspaces
  "workspaces": [
    "apps/*",     // Todas las apps
    "packages/*"  // Todos los paquetes
  ],
  // Scripts que se ejecutan en todos los workspaces
  "scripts": {
    "build": "turbo run build",
    "dev": "turbo run dev",
    "test": "turbo run test",
    "clean": "turbo run clean"
  },
  // Dependencias que se comparten en todos los workspaces
  "devDependencies": {
    "turbo": "^1.10.0",
    "typescript": "^5.0.0"
  }
}

Estructura Típica de un Monorepo

Estructura de carpetas recomendada
mi-monorepo/
├── 📄 package.json                 // Configuración principal
├── 🔧 turbo.json                  // Configuración de Turborepo
├── 📁 apps/                       // Aplicaciones ejecutables
│   ├── 🌐 web/                    // App Next.js principal
│   │   ├── package.json
│   │   ├── next.config.js
│   │   └── src/
│   ├── 📱 mobile/                 // App React Native
│   │   ├── package.json
│   │   └── src/
│   └── 🔐 admin/                  // Panel de administración
│       ├── package.json
│       └── src/
├── 📦 packages/                   // Librerías compartidas
│   ├── 🧩 ui/                     // Componentes de interfaz
│   │   ├── package.json
│   │   └── src/components/
│   ├── 🛠️ utils/                  // Utilidades comunes
│   │   ├── package.json
│   │   └── src/helpers/
│   └── ⚙️ config/                 // Configuraciones
│       ├── package.json
│       └── eslint-config/
└── 📚 docs/                       // Documentación
⚠️ Consejo para principiantes: No intentes implementar toda la estructura de una vez. Empieza con algo simple: una app y un paquete compartido, luego ve añadiendo más proyectos gradualmente.

Turborepo

Turborepo es una herramienta creada por Vercel (los creadores de Next.js) que hace que los monorepos sean súper rápidos y eficientes. Es como tener un "cerebro inteligente" que organiza y optimiza todas las tareas de tu proyecto.

¿Por qué Turborepo es especial?

🧠 Caching Inteligente

Guarda los resultados de tareas anteriores para no repetir trabajo. Como tener una memoria fotográfica: si ya hiciste algo, no lo haces otra vez.

⚡ Pipelines Paralelos

Ejecuta múltiples tareas al mismo tiempo, aprovechando al máximo tu computadora. Es como tener varios trabajadores haciendo cosas diferentes simultáneamente.

🔗 Dependencias Inteligentes

Detecta automáticamente qué necesita ejecutarse y en qué orden. Si cambias una librería, solo recompila lo que la usa.

Configuración Básica de Turborepo

La configuración de Turborepo se hace en el archivo turbo.json. Este archivo le dice a Turborepo cómo organizar las tareas y qué depende de qué.

turbo.json - Configuración de Turborepo
// Define el esquema de validación
{
  "$schema": "https://turbo.build/schema.json",
  
  // Define el "pipeline" o flujo de tareas
  "pipeline": {
    
    // Tarea de construcción
    "build": {
      // Depende de que las dependencias (^) estén construidas primero
      "dependsOn": ["^build"],
      // Define qué archivos produce esta tarea (para el cache)
      "outputs": ["dist/**", ".next/**", "build/**"]
    },
    
    // Tarea de desarrollo
    "dev": {
      // No se cachea, porque el dev server siempre cambia
      "cache": false
    },
    
    // Tarea de testing
    "test": {
      "dependsOn": ["build"],
      "outputs": []
    },
    
    // Tarea de linting
    "lint": {
      "dependsOn": [],
      "outputs": []
    },
    
    // Tarea de limpiar
    "clean": {
      "cache": false
    }
  }
}

¿Cómo funciona el Caching?

El sistema de caché de Turborepo es como un "cerebro con memoria fotográfica":

  1. Primera vez: Ejecuta la tarea normalmente y guarda el resultado en caché
  2. Segunda vez: Verifica si algo cambió (archivos, dependencias, etc.)
  3. Si nada cambió: Usa el resultado cacheado directamente (¡súper rápido!)
  4. Si algo cambió: Solo recalcula lo que realmente necesita cambiar
💡 Ejemplo práctico: Si cambias solo el CSS de un componente, Turborepo solo recompila ese componente y los que dependen de él, no todo el proyecto.

Scripts en package.json de un proyecto individual

apps/web/package.json - Ejemplo de configuración
{
  "name": "@mi-monorepo/web",
  "version": "1.0.0",
  "private": true,
  
  // Scripts que se ejecutan con turbo
  "scripts": {
    "build": "next build",        // Construye la app
    "dev": "next dev",          // Servidor de desarrollo
    "start": "next start",        // Producción
    "lint": "next lint",          // Revisar código
    "test": "jest",              // Ejecutar tests
    "clean": "rm -rf .next dist"  // Limpiar archivos
  },
  
  // Dependencias específicas de este proyecto
  "dependencies": {
    "next": "13.4.0",
    "react": "18.2.0",
    "@mi-monorepo/ui": "workspace:*",     // Usa la librería local
    "@mi-monorepo/utils": "workspace:*"      // Usa las utilidades locales
  },
  
  // Dependencias de desarrollo
  "devDependencies": {
    "@types/node": "^18.0.0",
    "@types/react": "^18.0.0",
    "typescript": "^5.0.0"
  }
}

Comandos Útiles de Turborepo

Comandos de terminal
# Ejecutar build en todos los proyectos (en paralelo)
npm run build

# Ejecutar dev server en todos los proyectos
npm run dev

# Ejecutar tests en todos los proyectos
npm run test

# Ejecutar solo el build de un proyecto específico
turbo run build --filter="@mi-monorepo/web"

# Ver el grafo de dependencias
turbo run build --graph

# Ejecutar build sin usar caché (para debugging)
turbo run build --force

# Ejecutar build con información de rendimiento
turbo run build --profile

Nx

Nx es una herramienta de monorepos creada por los desarrolladores del framework Angular. Es como tener un "conjunto de herramientas completo" que no solo gestiona monorepos, sino que también incluye generadores de código, análisis visual de dependencias y mucho más.

Características Únicas de Nx

🏗️ Generadores de Código

Plantillas automáticas para crear componentes, librerías, servicios, etc. Es como tener un "moldeador de código" que crea código base para ti.

📊 Análisis Visual

Gráficos que muestran qué depende de qué en tu proyecto. Como un mapa de las conexiones entre todos tus proyectos.

🛠️ Extensibilidad

Soporte oficial para múltiples frameworks: Angular, React, Vue, Node.js, y más.

Configuración de Nx

Nx se configura principalmente con project.json (uno por proyecto) y un nx.json general. También usa workspace.json para la configuración del workspace.

nx.json - Configuración global de Nx
{
  "npmScope": "mi-monorepo",
  "affected": {
    "defaultBase": "main"
  },
  "tasksRunnerOptions": {
    "default": {
      "runner": "@nrwl/workspace/tasks-runners/default",
      "options": {
        "cacheableOperations": ["build", "lint", "test", "e2e"]
      }
    }
  },
  "targetDependencies": {
    "build": [
      {
        "target": "build",
        "projects": "dependencies"
      }
    ]
  },
  "generators": {
    "@nrwl/angular:application": {
      "style": "scss",
      "linter": "eslint",
      "unitTestRunner": "jest",
      "e2eTestRunner": "cypress"
    }
  }
}

Generadores de Código

Los generadores son como "plantillas mágicas" que crean código base para ti. Nx viene con muchos generadores integrados:

Comandos de generación con Nx
# Generar una nueva aplicación React
npx nx generate @nrwl/react:application mi-app-web

# Generar una librería de componentes React
npx nx generate @nrwl/react:library componentes-ui

# Generar un componente específico en la librería
npx nx generate @nrwl/react:component Boton --project=componentes-ui

# Generar un servicio para una API
npx nx generate @nrwl/node:service usuario-service

# Generar una app Angular
npx nx generate @nrwl/angular:application mi-app-angular

# Generar una librería de utilidades
npx nx generate @nrwl/js:library utilidades-fecha

Analizador de Dependencias

Nx puede generar gráficos visuales de las dependencias entre proyectos. Esto es súper útil para entender cómo está estructurado tu monorepo.

Comandos de análisis
# Ver el grafo de dependencias en el navegador
npx nx graph

# Ver qué se ve afectado por un cambio
npx nx affected:graph

# Mostrar información de un proyecto específico
npx nx show project mi-app-web --verbose

# Listar todos los proyectos en el workspace
npx nx show projects

Configuración de un Proyecto Individual

apps/web/project.json - Configuración de proyecto Nx
{
  "$schema": "./node_modules/nx/schemas/project-schema.json",
  "sourceRoot": "apps/web/src",
  "projectType": "application",
  "targets": {
    "build": {
      "executor": "@nrwl/next:build",
      "outputs": ["{options.outputPath}"],
      "options": {
        "root": "apps/web",
        "outputPath": "dist/apps/web",
        "config": "production"
      }
    },
    "serve": {
      "executor": "@nrwl/next:serve",
      "options": {
        "buildTarget": "web:build",
        "dev": true
      }
    },
    "test": {
      "executor": "@nrwl/jest:jest",
      "outputs": ["{workspaceRoot}/coverage/{projectRoot}"],
      "options": {
        "jestConfig": "apps/web/jest.config.ts"
      }
    },
    "lint": {
      "executor": "@nrwl/linter:eslint",
      "options": {
        "lintFilePatterns": ["apps/web/**/*.{ts,tsx,js,jsx}"]
      }
    }
  },
  "tags": []
}
✅ Ventaja de Nx: Los generadores de código y la configuración estructurada hacen que sea muy fácil mantener consistencia en grandes proyectos con muchos desarrolladores.

Turborepo vs Nx: ¿Cuál elegir?

Ambos son excelentes herramientas, pero cada una tiene sus fortalezas. Aquí te ayudamos a decidir cuál es mejor para tu proyecto.

Característica Turborepo Nx
Simplicidad ✅ Muy simple de configurar ⚠️ Más complejo inicialmente
Generadores de código ❌ No incluidos ✅ Extensivos y personalizables
Visualización de dependencias ⚠️ Básico (solo terminal) ✅ Gráficos interactivos
Framework-agnóstico ✅ Perfecto para cualquier stack ✅ Soporte nativo para múltiples frameworks
Rendimiento de build ✅ Excelente, foco en velocidad ✅ Muy bueno, también rápido
Curva de aprendizaje ✅ Rápida (2-3 días) ⚠️ Moderada (1-2 semanas)
Ecosistema 🆕 Más nuevo, creciendo ✅ Maduro y estable
Gestión de plugins ✅ Simple, JSON-based ✅ Sistema robusto de plugins
Detección de cambios ✅ Inteligente y precisa ✅ Muy avanzada
Documentación ✅ Excelente y clara ✅ Completa pero densa

¿Cuándo elegir Turborepo?

🆕 Proyectos Nuevos

Si estás empezando un proyecto desde cero y quieres algo que funcione rápido y sin complicaciones.

⚡ Enfoque en Velocidad

Si lo más importante para ti son builds súper rápidos y no necesitas generadores de código.

📦 Stack Múltiple

Si tu proyecto usa diferentes tecnologías (React + Node + Python, etc.) sin un framework dominante.

¿Cuándo elegir Nx?

🏢 Proyectos Grandes

Si tienes muchos proyectos y desarrolladores, Nx te ayuda a mantener la consistencia.

🎨 Necesitas Generadores

Si quieres plantillas automáticas para crear componentes, servicios, librerías, etc.

📊 Necesitas Visualización

Si necesitas entender las dependencias entre proyectos de forma visual.

Matriz de Decisión

🎯 ¿Cuál es tu situación?

Responde estas preguntas para ayudarte a decidir:

1. ¿Qué tan grande es tu equipo?
2. ¿Qué tan complejo es tu proyecto?
3. ¿Qué es más importante para ti?

Haz clic en los botones de arriba para ver recomendaciones.

Tutorial Paso a Paso

Te guiaré a través de la creación de un monorepo desde cero. Empezaremos simple y luego añadiremos complejidad.

📋 Prerrequisitos

🚀 Parte 1: Configuración Básica con Turborepo

Paso 1: Crear el proyecto base

Terminal - Crear monorepo con Turborepo
# 1. Crear directorio del proyecto
mkdir mi-monorepo-turborepo
cd mi-monorepo-turborepo

# 2. Inicializar package.json
npm init -y

# 3. Instalar Turborepo como dependencia de desarrollo
npm install -D turbo

# 4. Crear la estructura de carpetas
mkdir -p apps web
mkdir -p packages utils

# 5. Configurar workspaces en package.json
package.json - Configuración inicial
{
  "name": "mi-monorepo-turborepo",
  "version": "1.0.0",
  "private": true,
  "workspaces": [
    "apps/*",
    "packages/*"
  ],
  "scripts": {
    "build": "turbo run build",
    "dev": "turbo run dev",
    "test": "turbo run test",
    "clean": "turbo run clean"
  },
  "devDependencies": {
    "turbo": "^1.10.0"
  }
}

Paso 2: Configurar Turborepo

turbo.json - Configuración de Turborepo
{
  "$schema": "https://turbo.build/schema.json",
  "pipeline": {
    "build": {
      "dependsOn": ["^build"],
      "outputs": ["dist/**", ".next/**", "build/**"]
    },
    "test": {
      "dependsOn": ["build"]
    },
    "lint": {
      "dependsOn": []
    },
    "dev": {
      "cache": false
    },
    "clean": {
      "cache": false
    }
  }
}
💡 ¿Qué hace esta configuración?
  • "dependsOn": ["^build"]: Espera a que las dependencias se construyan primero
  • "outputs": Define qué archivos produce cada tarea (para el cache)
  • "cache": false: No cachea estas tareas

Paso 3: Crear Primera Aplicación

apps/web/package.json - App Next.js
{
  "name": "@mi-monorepo/web",
  "version": "0.0.0",
  "private": true,
  "scripts": {
    "build": "next build",
    "dev": "next dev",
    "lint": "next lint",
    "test": "echo 'No tests yet' && exit 0"
  },
  "dependencies": {
    "next": "13.4.19",
    "react": "18.2.0",
    "react-dom": "18.2.0"
  },
  "devDependencies": {
    "@types/node": "20.5.7",
    "@types/react": "18.2.21",
    "@types/react-dom": "18.2.7",
    "eslint": "8.48.0",
    "typescript": "5.2.2"
  }
}
apps/web/next.config.js
// @type {import('next').NextConfig}
const nextConfig = {
  reactStrictMode: true,
  swcMinify: true,
}

module.exports = nextConfig

Paso 4: Crear Librería Compartida

packages/utils/package.json - Librería de utilidades
{
  "name": "@mi-monorepo/utils",
  "version": "0.0.0",
  "main": "./dist/index.js",
  "types": "./dist/index.d.ts",
  "scripts": {
    "build": "tsc",
    "dev": "tsc --watch",
    "test": "jest",
    "lint": "echo 'No linting configured yet'",
    "clean": "rm -rf dist"
  },
  "devDependencies": {
    "typescript": "^5.0.0"
  }
}
packages/utils/tsconfig.json - Configuración TypeScript
{
  "compilerOptions": {
    "target": "es5",
    "lib": ["dom", "dom.iterable", "es6"],
    "allowJs": true,
    "skipLibCheck": true,
    "strict: true,
    "forceConsistentCasingInFileNames: true,
    "noEmit": false,
    "esModuleInterop": true,
    "module": "commonjs",
    "moduleResolution": "node",
    "resolveJsonModule": true,
    "isolatedModules": true,
    "outDir": "./dist",
    "declaration": true
  },
  "include": ["./src/**/*"],
  "exclude": ["node_modules", "dist"]
}
packages/utils/src/index.ts - Funciones utilitarias
// Función para formatear fechas
export function formatDate(date: Date, format: string = 'DD/MM/YYYY'): string {
  const day = date.getDate().toString().padStart(2, '0')
  const month = (date.getMonth() + 1).toString().padStart(2, '0')
  const year = date.getFullYear().toString()
  
  return format
    .replace('DD', day)
    .replace('MM', month)
    .replace('YYYY', year)
}

// Función para validar emails
export function isValidEmail(email: string): boolean {
  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/
  return emailRegex.test(email)
}

// Función para generar IDs únicos
export function generateId(): string {
  return `id_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`
}

// Función para formatear números como moneda
export function formatCurrency(amount: number, currency: string = 'EUR'): string {
  return new Intl.NumberFormat('es-ES', {
    style: 'currency',
    currency: currency,
  }).format(amount)
}
🎉 ¡Felicidades! Has creado tu primer monorepo con Turborepo. Ahora puedes ejecutar comandos en todos los proyectos a la vez.

Comandos de Pruebas

Probar el monorepo
# Instalar dependencias en todos los proyectos
npm install

# Ejecutar build en todos los proyectos
npm run build

# Ejecutar dev server en todos los proyectos (con Next.js)
npm run dev

# Ver información de Turbo
npx turbo run build --dry-run

# Ver el grafo de dependencias
npx turbo run build --graph

Casos de Uso Reales

Veamos cómo las empresas reales usan monorepos para resolver problemas reales del día a día.

🏢 Caso 1: Startup de E-commerce en Crecimiento

📊 Situación

Empresa: ShopNow (nombre ficticio)
Tamaño: 12 desarrolladores
Problema: Empezaron con una app web simple, pero ahora tienen múltiples productos y están perdiendo consistencia.

🎯 Solución con Monorepo

Estructura de ShopNow
shopnow-monorepo/
├── apps/
│   ├── 🛒 web-store/          // Tienda principal
│   ├── 📱 mobile-app/         // App React Native
│   ├── 🔐 admin-panel/        // Panel de administración
│   ├── 📧 email-service/      // Servicio de emails
│   └── 📊 analytics/          // Dashboard de analytics
├── packages/
│   ├── 🎨 ui-components/      // Botones, formularios, etc.
│   ├── 🛠️ api-client/         // Cliente HTTP compartido
│   ├── 🔐 auth/               // Lógica de autenticación
│   ├── 💰 pricing/            // Cálculos de precios
│   └── 📝 types/              // Tipos TypeScript
└── tools/
    ├── 🚀 deploy/             // Scripts de despliegue
    └── 🔧 ci/                 // Configuración CI/CD

✅ Beneficios Obtenidos

  • Mantenimiento reducido: Una sola configuración de ESLint, Prettier, TypeScript
  • Reutilización: Los componentes de UI se usan en web, mobile y admin
  • Consistencia: El cliente API es el mismo en todas las apps
  • Refactorización segura: Cambios en tipos se propagan automáticamente

🏛️ Caso 2: Empresa de Servicios Financieros

📊 Situación

Empresa: FinBank Corp (nombre ficticio)
Tamaño: 45 desarrolladores
Problema: Múltiples productos financieros (banca personal, empresarial, inversiones) con equipos independientes creando código duplicado.

🎯 Solución con Nx

Estructura de FinBank
finbank-monorepo/
├── apps/
│   ├── 🏦 personal-banking/   // App banca personal
│   ├── 🏢 business-banking/   // App banca empresarial
│   ├── 📈 investment-platform/ // Plataforma de inversiones
│   └── 🔐 compliance/         // Sistema de cumplimiento
├── packages/
│   ├── 💳 payment-core/       // Motor de pagos
│   ├── 🔐 security/           // Seguridad y cifrado
│   ├── 📊 reporting/          // Reportes financieros
│   ├── 🏛️ banking-core/       // Lógica bancaria
│   └── 🔍 kyc/                // Know Your Customer
├── tools/
│   ├── 🔧 generators/         // Generadores personalizados
│   └── 📋 compliance/         // Herramientas de compliance
└── docs/
    ├── 📖 architecture/       // Documentación arquitectura
    └── 🔒 security/           // Guías de seguridad

✅ Beneficios Obtenidos

  • Generadores Nx: Plantillas para crear nuevos productos financieros con compliance automático
  • Análisis visual: Gráficos para entender qué se ve afectado por cambios regulatorios
  • Consistencia legal: Mismas verificaciones KYC en todos los productos
  • Reutilización masiva: 70% de código compartido entre productos

🎮 Caso 3: Estudio de Desarrollo de Videojuegos

📊 Situación

Empresa: GameStudio (nombre ficticio)
Tamaño: 25 desarrolladores
Problema: Cada juego tenía su propio motor gráfico, herramientas y sistemas de build, causando mucha duplicación.

🎯 Solución con Monorepo

Estructura de GameStudio
gamestudio-monorepo/
├── games/
│   ├── 🎮 space-adventure/    // Juego de aventuras espaciales
│   ├── 🏎️ racing-game/        // Juego de carreras
│   └── 🧙 magic-quest/        // Juego de rol mágico
├── engines/
│   ├── 🔧 core-engine/        // Motor gráfico base
│   ├── 🎵 audio-system/       // Sistema de audio
│   └── 🌐 networking/         // Sistema multijugador
├── tools/
│   ├── 🎨 asset-pipeline/     // Pipeline de assets
│   ├── 📊 analytics/          // Analytics de juego
│   └── 🚀 deployment/         // Despliegue multiplataforma
├── packages/
│   ├── 🎭 characters/         // Personajes reutilizables
│   ├── 🏞️ environments/       // Entornos y escenarios
│   └── 🎯 gameplay/           // Mecánicas de juego
└── platforms/
    ├── 🖥️ desktop/            // Builds desktop
    ├── 📱 mobile/              // Builds móviles
    └── 🎮 console/             // Builds para consolas

✅ Beneficios Obtenidos

  • Motor unificado: Todos los juegos usan la misma base gráfica
  • Herramientas compartidas: Mismas herramientas de análisis y deployment
  • Assets reutilizables: Personajes y entornos se comparten entre juegos
  • Builds optimizados: Turborepo acelera significativamente los builds de juegos

📈 Métricas Reales de Éxito

⚡ Rendimiento de Build

Antes: 25 minutos build completo
Después: 6 minutos con cache
Ahorro: 76% de tiempo

👥 Productividad del Equipo

Antes: 3 días para configurar nuevo proyecto
Después: 2 horas con generadores Nx
Ahorro: 92% de tiempo

🐛 Errores de Inconsistencia

Antes: 12 bugs/mes por inconsistencias
Después: 2 bugs/mes
Reducción: 83% menos errores

📦 Duplicación de Código

Antes: 45% de código duplicado
Después: 12% de código duplicado
Ahorro: 73% menos duplicación

🎯 Cuándo NO usar Monorepos

⚠️ Evita monorepos si:
  • Proyectos completamente independientes: No comparten código, lógica o equipos
  • Equipos muy pequeños: 1-2 desarrolladores, overkill para proyectos simples
  • Stack tecnológico muy diferente: Python + Rust + Java sin relación
  • Clientes externos independientes: Cada cliente tiene requisitos únicos y separados

Recursos para Profundizar

Aquí tienes una colección de recursos para seguir aprendiendo y mantenerse actualizado.

📚 Documentación Oficial

📖 Turborepo

Documentación oficial

Guías completas, API reference y ejemplos prácticos.

📖 Nx

nx.dev

Documentación extensa, tutoriales y casos de uso.

📖 Monorepo.tools

monorepo.tools

Comparación independiente y guías neutrales sobre monorepos.

🎓 Tutoriales y Cursos

🛠️ Herramientas Complementarias

🔧 Gestores de Paquetes

  • Yarn Workspaces: Soporte nativo para monorepos
  • pnpm: Enfoque en eficiencia y espacio en disco
  • npm Workspaces: Soporte oficial desde npm 7

🔍 Herramientas de Análisis

  • Madge: Análisis de dependencias
  • dependency-cruiser: Validación de arquitectura
  • ws-size: Análisis de tamaños

🚀 CI/CD

  • GitHub Actions: Soporte nativo para monorepos
  • GitLab CI: Configuración para workspaces
  • CircleCI: Optimizaciones para monorepos

💡 Consejos Adicionales

🎯 Mejores Prácticas

  1. Empieza simple: No trates de implementar toda la estructura de una vez
  2. Documenta tu estructura: Un README claro que explique la organización
  3. Usa TypeScript: Hace que la integración entre proyectos sea más robusta
  4. Configura linting global: ESLint y Prettier compartidos
  5. Tests en cada nivel: Unitarios, integración y e2e
  6. Versionado semántico: Para las librerías internas

🆘 Resolución de Problemas Comunes

❌ Error: "Cannot find module"

Problema: No puede encontrar un paquete interno
Solución: Verifica que el package.json use "workspace:*" para dependencias internas

❌ Error: "Build fails in CI but works locally"

Problema: Cache de CI no incluye dependencias
Solución: Configura cache en tu CI para incluir node_modules y .turbo

❌ Build muy lento en CI

Problema: No se está usando el cache correctamente
Solución: Asegúrate de que los outputs en turbo.json sean correctos y específicos

🔄 Mantente Actualizado

Las herramientas de monorepo evolucionan rápidamente. Te recomendamos:

Volver al Inicio