@batistafull/deploy-server 1.1.0 → 3.0.0

package/README.md

@@ -0,0 +1,136 @@
+# @batistafull/deploy-server
+
+Herramienta CLI de despliegue dirigida por configuración. Ejecuta los comandos de build de tu proyecto y copia las carpetas, archivos o globs que indiques a la carpeta destino, con opción de subir el resultado por FTP/FTPS.
+
+## Instalación
+
+Global:
+
+```bash
+npm install -g @batistafull/deploy-server
+```
+
+O como dependencia de desarrollo del proyecto:
+
+```bash
+npm install --save-dev @batistafull/deploy-server
+```
+
+## Uso
+
+Desde la raíz de tu proyecto, crea un archivo `deploy.config.json` (ver formato abajo) y ejecuta:
+
+```bash
+deploy-server
+```
+
+### Opciones
+
+| Opción            | Descripción                                    | Por defecto          |
+| ----------------- | ---------------------------------------------- | -------------------- |
+| `--config <path>` | Ruta al archivo de configuración               | `deploy.config.json` |
+| `--clean`         | Limpia la carpeta de salida antes de desplegar | (desactivado)        |
+| `-h, --help`      | Muestra la ayuda                               |                      |
+
+Ejemplos:
+
+```bash
+# Deploy con la config por defecto
+deploy-server
+
+# Limpiar la salida antes de copiar
+deploy-server --clean
+
+# Usar otro archivo de config
+deploy-server --config configs/prod.json
+```
+
+## Configuración
+
+Crea `deploy.config.json` en la raíz de tu proyecto. **Este archivo lo creas tú**, no viene incluido en el paquete.
+
+```json
+{
+  "output": "C:/inetpub/app.host",
+  "sources": ["dist/", "api/", "robots.txt"],
+  "buildCommand": ["npm install", "npm run build"],
+  "exclude": ["dist/.htaccess", "api/node_modules"],
+  "ftp": {
+    "enabled": false,
+    "host": "ftp.example.com",
+    "secure": true,
+    "remotePath": "/public_html"
+  }
+}
+```
+
+### Campos
+
+| Campo          | Tipo                  | Descripción                                                 |
+| -------------- | --------------------- | ----------------------------------------------------------- |
+| `output`       | `string`              | Ruta destino del deploy (ver nota abajo).                   |
+| `sources`      | `string[]`            | Carpetas, archivos o globs a copiar (ver abajo).            |
+| `buildCommand` | `string` o `string[]` | Comando(s) de build. Si es un array, se ejecutan en orden.  |
+| `exclude`      | `string[]`            | Rutas a excluir, relativas al proyecto (ver abajo).         |
+| `ftp`          | `object`              | (Opcional) Configuración de subida por FTP/FTPS. Ver abajo. |
+
+> **`output`:** si es una ruta **absoluta** se usa tal cual (ej: `C:/inetpub/app.host`);
+> si es **relativa** se resuelve desde la raíz del proyecto (ej: `../deploy/app.host`).
+
+### `sources` — qué se copia
+
+Cada entrada es una carpeta, un archivo o un glob, relativo a la raíz del proyecto:
+
+| Entrada      | Significado                                                                      |
+| ------------ | -------------------------------------------------------------------------------- |
+| `dist/`      | Carpeta completa (recursivo). Su contenido se copia a la raíz del output.        |
+| `dist/*.css` | Glob: solo los `.css` del primer nivel de `dist`, copiados a la raíz del output. |
+| `robots.txt` | Un archivo suelto, copiado por su nombre a la raíz del output.                   |
+
+En todos los casos el contenido se copia a la **raíz del output** (se quita la carpeta base). Las carpetas se indican con `/` al final.
+
+### `exclude` — qué se omite
+
+Cada entrada es una ruta **relativa al proyecto** (no un nombre suelto), scopeada a la carpeta de origen:
+
+- `"dist/.htaccess"` → omite ese archivo concreto dentro de `dist`.
+- `"api/node_modules"` → omite esa carpeta entera (y su contenido) dentro de `api`.
+
+### FTP / FTPS
+
+La subida por FTP está desactivada salvo que pongas `ftp.enabled: true`.
+
+| Campo            | Descripción                                                                |
+| ---------------- | -------------------------------------------------------------------------- |
+| `ftp.enabled`    | `true` para activar la subida.                                             |
+| `ftp.host`       | Host del servidor FTP (fallback de `FTP_HOST`).                            |
+| `ftp.secure`     | `true` (por defecto) usa FTPS con TLS. Pon `false` solo si no hay soporte. |
+| `ftp.remotePath` | Carpeta remota destino.                                                    |
+
+> **Seguridad:** las credenciales se leen preferentemente de variables de entorno.
+> **No pongas la contraseña en el JSON.**
+
+```bash
+# Linux / macOS
+FTP_HOST=ftp.tuservidor.com FTP_USER=usuario FTP_PASSWORD=secreto deploy-server
+```
+
+```powershell
+# Windows (PowerShell)
+$env:FTP_HOST="ftp.tuservidor.com"; $env:FTP_USER="usuario"; $env:FTP_PASSWORD="secreto"
+deploy-server
+```
+
+Si el FTP está habilitado y faltan `FTP_HOST`, `FTP_USER` o `FTP_PASSWORD` (y tampoco están en el config), el deploy falla con un error claro.
+
+## Qué hace, paso a paso
+
+1. Carga el `deploy.config.json`.
+2. Si se pasa `--clean`, borra la carpeta de salida.
+3. Ejecuta el/los `buildCommand`.
+4. Copia cada entrada de `sources` → `<output>` (aplicando `exclude`).
+5. Si `ftp.enabled`, sube la carpeta de salida por FTP/FTPS.
+
+## Licencia
+
+MIT

package/lib/deploy.js

@@ -1,9 +1,9 @@
 const path = require("path");
-const os = require("os");
 const fs = require("fs-extra");
 const chalk = require("chalk");
 const { execSync } = require("child_process");
 const ftp = require("basic-ftp");
+const fg = require("fast-glob");
 
 // Ejecuta una lista de comandos de build en orden
 function runBuildCommands(commands, cwd) {
@@ -13,23 +13,67 @@ function runBuildCommands(commands, cwd) {
   }
 }
 
-// Copia un directorio excluyendo los patrones indicados (match por nombre o ruta relativa)
-async function copyFiltered(srcPath, destPath, exclude = []) {
-  if (!(await fs.pathExists(srcPath))) {
-    console.log(chalk.yellow(`⚠️  Origen no encontrado, se omite: ${srcPath}`));
-    return;
+// Dado un patrón (con "/"), calcula el patrón glob y la carpeta base a "quitar"
+// al copiar hacia el output.
+//   "dist/"        -> { glob: "dist/**/*",  base: "dist" }  (carpeta completa)
+//   "dist/*.css"   -> { glob: "dist/*.css", base: "dist" }  (glob dentro de dist)
+//   "dist/app.js"  -> { glob: "dist/app.js", base: "dist" } (archivo suelto)
+function resolveSource(raw) {
+  const source = raw.replace(/\\/g, "/");
+  const hasGlob = (s) => /[*?[\]{}!()]/.test(s);
+
+  if (source.endsWith("/")) {
+    const dir = source.replace(/\/+$/, "");
+    return { glob: `${dir}/**/*`, base: dir };
   }
 
-  await fs.copy(srcPath, destPath, {
-    filter: (src) => {
-      const relative = path.relative(srcPath, src);
-      if (!relative) return true; // el propio directorio raíz
-      const name = path.basename(src);
-      return !exclude.some(
-        (pattern) => name === pattern || relative.split(path.sep).includes(pattern)
-      );
+  if (hasGlob(source)) {
+    // base = prefijo estático anterior al primer segmento con comodines
+    const baseSegs = [];
+    for (const seg of source.split("/")) {
+      if (hasGlob(seg)) break;
+      baseSegs.push(seg);
     }
+    return { glob: source, base: baseSegs.join("/") || "." };
+  }
+
+  // archivo (o carpeta sin "/") suelto: se copia bajo su nombre
+  return { glob: source, base: path.posix.dirname(source) };
+}
+
+// Copia cada 'source' al output. Los 'exclude' son rutas relativas al proyecto
+// (ej: "dist/.htaccess") y se aplican como patrones ignorados.
+async function copySources(sources, outputPath, exclude, projectRoot) {
+  // Para excluir una carpeta entera basta con nombrarla; añadimos "/**" para
+  // cubrir también su contenido.
+  const ignore = exclude.flatMap((e) => {
+    const p = e.replace(/\\/g, "/").replace(/\/+$/, "");
+    return [p, `${p}/**`];
   });
+
+  for (const raw of sources) {
+    const { glob, base } = resolveSource(raw);
+
+    const matches = await fg(glob, {
+      cwd: projectRoot,
+      dot: true,
+      onlyFiles: true,
+      ignore
+    });
+
+    if (matches.length === 0) {
+      console.log(chalk.yellow(`⚠️  Sin coincidencias, se omite: ${raw}`));
+      continue;
+    }
+
+    console.log(chalk.blue(`📦 Copiando ${raw} (${matches.length} archivo(s))...`));
+    for (const rel of matches) {
+      const from = path.join(projectRoot, rel);
+      const dest = path.join(outputPath, path.relative(base, rel));
+      await fs.ensureDir(path.dirname(dest));
+      await fs.copy(from, dest);
+    }
+  }
 }
 
 module.exports = async function deploy(options) {
@@ -37,15 +81,19 @@ module.exports = async function deploy(options) {
 
   const projectRoot = process.cwd();
 
-  const documentsPath =
-    process.platform === "win32"
-      ? path.join(process.env.USERPROFILE, "Documents")
-      : path.join(os.homedir(), "Documents");
+  if (!config.output) {
+    throw new Error("Falta 'output' en el config: indica la carpeta destino del deploy.");
+  }
 
-  const outputPath = path.join(documentsPath, config.output);
+  if (!Array.isArray(config.sources) || config.sources.length === 0) {
+    throw new Error(
+      "Falta 'sources' en el config: indica un array de carpetas/archivos a copiar (ej: [\"dist/\", \"api/\"])."
+    );
+  }
 
-  const distPath = path.join(projectRoot, config.dist);
-  const serverPath = path.join(projectRoot, config.server);
+  // 'output' es la ruta destino. Si es absoluta se usa tal cual;
+  // si es relativa se resuelve desde la raíz del proyecto.
+  const outputPath = path.resolve(projectRoot, config.output);
 
   // Clean
   if (options.clean) {
@@ -65,13 +113,8 @@ module.exports = async function deploy(options) {
     });
   }
 
-  // COPY DIST
-  console.log(chalk.blue("📦 Copying dist..."));
-  await copyFiltered(distPath, outputPath, config.exclude || []);
-
-  // COPY SERVER
-  console.log(chalk.blue("📦 Copying server..."));
-  await copyFiltered(serverPath, outputPath, config.exclude || []);
+  // COPY SOURCES
+  await copySources(config.sources, outputPath, config.exclude || [], projectRoot);
 
   // FTP (opcional)
   if (config.ftp?.enabled) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@batistafull/deploy-server",
-  "version": "1.1.0",
-  "description": "Deploy tool that builds and copies dist + api to Documents/app.host",
+  "version": "3.0.0",
+  "description": "Config-driven deploy tool that builds and copies folders, files or globs to a target path, with optional FTP/FTPS upload",
   "main": "bin/deploy-server.js",
   "bin": {
     "deploy-server": "bin/deploy-server.js"
@@ -10,7 +10,11 @@
     "bin/",
     "lib/"
   ],
-  "keywords": ["deploy", "cli", "nodejs"],
+  "keywords": [
+    "deploy",
+    "cli",
+    "nodejs"
+  ],
   "author": "batistafull",
   "license": "MIT",
   "type": "commonjs",
@@ -21,6 +25,7 @@
     "basic-ftp": "^5.0.5",
     "chalk": "^4.1.2",
     "commander": "^12.1.0",
+    "fast-glob": "^3.3.3",
     "fs-extra": "^11.2.0"
   }
-}
+}