# 🔧 Guía Técnica: create-complete-project.sh

## 📋 Arquitectura

El script `create-complete-project.sh` actúa como **orquestador** que coordina múltiples scripts y comandos para crear un proyecto completo.

```
create-complete-project.sh
    │
    ├─── FASE 1: Lectura de Configuración
    │    └─── Lee JSON o modo interactivo
    │
    ├─── FASE 2: Creación del Proyecto
    │    └─── create-new-project.sh
    │         └─── clone-to-new-repo.sh
    │
    ├─── FASE 3: Configuración del Proyecto
    │    └─── setup_cd_project.sh
    │         ├─── composer install
    │         ├─── Configura .env
    │         └─── migrate:fresh --seed
    │
    ├─── FASE 4: Personalización
    │    ├─── Configura identidad (config/site.php)
    │    ├─── Configura demo y módulos (config/cd-system.php)
    │    └─── Procesa assets (project:update-assets)
    │
    └─── FASE 5: Verificación
         └─── Verifica estado final
```

---

## 🔄 Flujo de Ejecución

### 1. Inicialización

```bash
# Verifica que estamos en cd-system
# Verifica que jq está instalado (si se usa JSON)
# Detecta directorios (cd-system, parent)
```

### 2. Lectura de Configuración

**Modo JSON:**
```bash
# Lee valores del JSON usando jq
PROJECT_NAME=$(read_json_nested ".project.name" "$JSON_CONFIG")
# ... más valores
```

**Modo Interactivo:**
```bash
# Pregunta valores al usuario
read -p "Nombre del proyecto: " PROJECT_NAME
```

### 3. Creación del Proyecto

```bash
# Crea JSON temporal mínimo para create-new-project.sh
# Ejecuta: create-new-project.sh --json temp.json
```

**create-new-project.sh hace:**
- Crea directorio del proyecto
- Inicializa Git
- Configura remote origin
- Ejecuta `clone-to-new-repo.sh` (clona desde CD-System)

### 4. Configuración del Proyecto

```bash
# Ejecuta: setup_cd_project.sh
# Pasa input por stdin y CPANEL como variable de entorno
```

**setup_cd_project.sh hace:**
- Instala dependencias (`composer install`)
- Crea/actualiza `.env`
- Configura `APP_ENV=local` (en local)
- Configura `DB_USERNAME=root` y `DB_PASSWORD=` (en local)
- Genera `APP_KEY`
- Ejecuta `migrate:fresh --seed`

### 5. Personalización

**Identidad:**
```bash
# Actualiza config/site.php usando artisan o sed
php artisan project:customize-identity \
    --name="$SITE_NAME" \
    --url="$SITE_URL" \
    --email="$CONTACT_EMAIL" \
    --description="$SEO_DESCRIPTION" \
    --author="$AUTHOR"
```

**Demo y Módulos:**
```bash
# Actualiza config/cd-system.php
php artisan project:configure-modules \
    --demo="$DEMO" \
    --modules="$MODULES_JSON"
```

**Assets:**
```bash
# Copia assets a public/cd-project/assets/
# Ejecuta: php artisan project:update-assets
php artisan project:update-assets "$TARGET_ASSETS_DIR" --backup --project="$PROJECT_NAME"
```

### 6. Verificación

```bash
# Verifica rama Git
# Verifica .gitattributes
# Verifica archivos críticos
```

---

## 🔗 Scripts Relacionados

### create-new-project.sh

**Ubicación:** `scripts/create-new-project.sh`

**Propósito:** Crea el proyecto básico (directorio, Git, clonado)

**Uso desde create-complete-project.sh:**
```bash
# Crea JSON temporal mínimo
TEMP_JSON=$(mktemp)
cat > "$TEMP_JSON" <<EOF
{
  "project": {
    "name": "$PROJECT_NAME",
    "repository_url": "$REPO_URL",
    "branch": "cd-system"
  },
  "assets": {
    "has_assets": false
  }
}
EOF

# Ejecuta en modo JSON
"$CREATE_SCRIPT" --json "$TEMP_JSON"
```

### setup_cd_project.sh

**Ubicación:** `{PROJECT_DIR}/scripts/setup_cd_project.sh`

**Propósito:** Configura el proyecto (composer, .env, migraciones)

**Uso desde create-complete-project.sh:**
```bash
# Crea input temporal
TEMP_SETUP_INPUT=$(mktemp)
{
    echo "$PROJECT_NAME"
    echo "$DB_NAME"
    if [[ "$CPANEL" == "s" ]]; then
        echo "$DB_USER"
        echo "$DB_PASS"
        echo "$GA_ID"
    fi
} > "$TEMP_SETUP_INPUT"

# Pasa CPANEL como variable de entorno
export CPANEL="$CPANEL"
"$SETUP_SCRIPT" < "$TEMP_SETUP_INPUT"
```

**Nota:** `CPANEL` se pasa como variable de entorno para evitar problemas de sincronización con stdin.

---

## 🔧 Funciones Principales

### read_json_nested()

```bash
read_json_nested() {
    local path=$1
    local json_file=$2
    if [ "$HAS_JQ" = true ]; then
        jq -r "$path" "$json_file" 2>/dev/null
    else
        print_warning "jq no está instalado..."
        return 1
    fi
}
```

**Uso:**
```bash
PROJECT_NAME=$(read_json_nested ".project.name" "$JSON_CONFIG")
```

### Funciones de Output

- `print_header()` - Encabezado con línea decorativa
- `print_message()` - Mensaje informativo (verde)
- `print_warning()` - Advertencia (amarillo)
- `print_error()` - Error (rojo)
- `print_step()` - Paso del proceso (azul)
- `print_success()` - Éxito (verde con ✓)
- `print_question()` - Pregunta (cyan)

---

## 📝 Variables Importantes

### Variables de Entorno

- `CPANEL` - Se pasa como variable de entorno a `setup_cd_project.sh`

### Variables del Script

- `PROJECT_NAME` - Nombre del proyecto
- `REPO_URL` - URL del repositorio
- `DB_NAME` - Nombre de la base de datos
- `IS_CPANEL` - Si es cPanel o local
- `SITE_NAME`, `SITE_URL`, etc. - Configuración de identidad
- `DEMO` - Demo a usar
- `MODULES_JSON` - JSON de módulos
- `HAS_ASSETS`, `ASSETS_DIR` - Configuración de assets

---

## 🛠️ Modificaciones y Extensión

### Agregar Nuevo Campo al JSON

1. **Leer el valor:**
```bash
NUEVO_CAMPO=$(read_json_nested ".nueva_seccion.campo" "$JSON_CONFIG")
```

2. **Usar el valor:**
```bash
# En la sección correspondiente
if [ -n "$NUEVO_CAMPO" ] && [ "$NUEVO_CAMPO" != "null" ]; then
    # Hacer algo con el valor
fi
```

### Agregar Nueva Fase

1. **Agregar encabezado:**
```bash
print_header "FASE X: Nueva Fase"
```

2. **Agregar lógica:**
```bash
print_step "Ejecutando nueva fase..."
# Tu código aquí
print_success "Nueva fase completada"
```

### Modificar Comportamiento de Assets

El procesamiento de assets está en la **FASE 4**. Puedes modificar:

- Ruta de destino
- Archivos a copiar
- Comandos artisan a ejecutar

---

## 🐛 Debugging

### Habilitar Modo Verbose

El script ya tiene modo verbose por defecto. Para más detalles:

```bash
# Agregar al inicio del script
set -x  # Muestra cada comando ejecutado
```

### Verificar Valores Leídos del JSON

```bash
# Agregar después de leer JSON
print_message "Valores leídos:"
print_message "  PROJECT_NAME: $PROJECT_NAME"
print_message "  REPO_URL: $REPO_URL"
# ... más valores
```

### Verificar Input a setup_cd_project.sh

```bash
# Antes de ejecutar setup_cd_project.sh
print_message "Input para setup:"
cat "$TEMP_SETUP_INPUT"
```

---

## 📚 Dependencias

### Scripts Requeridos

- `create-new-project.sh` - Debe existir en `scripts/`
- `setup_cd_project.sh` - Se copia al proyecto durante la creación

### Herramientas Requeridas

- `jq` - Para parsear JSON (modo JSON)
- `git` - Para clonar y gestionar repositorios
- `composer` - Para instalar dependencias
- `php` - Para ejecutar comandos artisan
- `mysql` - Para crear base de datos (local)

---

## 🔒 Seguridad

### Credenciales

- Las contraseñas se leen con `read -s` (modo interactivo)
- No se muestran en logs
- Se pasan por stdin (no en argumentos de línea de comandos)

### Validación

- Valida nombre del proyecto (solo caracteres permitidos)
- Valida JSON (sintaxis correcta)
- Verifica que los scripts requeridos existan

---

## 📊 Rendimiento

### Tiempo Estimado

- **Creación del proyecto:** ~2-3 minutos
- **Instalación de dependencias:** ~3-5 minutos
- **Migraciones y seeders:** ~1-2 minutos
- **Procesamiento de assets:** ~30 segundos
- **Total:** ~7-11 minutos

### Optimizaciones

- Usa `--no-interaction` en composer
- Usa `--force` en comandos artisan
- Copia assets directamente (no procesa uno por uno)

---

## 🔄 Mantenimiento

### Actualizar el Script

1. Hacer cambios en `scripts/create-complete-project.sh`
2. Probar con proyecto de prueba
3. Actualizar documentación si es necesario
4. Commit y push

### Versionado

El script no tiene versionado interno. Se recomienda:

- Usar Git tags para versiones importantes
- Documentar cambios en [Changelog](./06-changelog.md)

---

**Siguiente:** [Ejemplos](./04-ejemplos.md)