docs(i18n): guide (es)

Author: vishr

site/src/content/docs/es/guide/binding.md

@@ -0,0 +1,150 @@
+---
+title: Binding
+description: Analiza datos de request en structs Go tipados desde path, query, header y body.
+sidebar:
+  order: 5
+---
+
+Analizar datos de request es una parte crucial de una aplicación web. En Echo esto se llama
+_binding_, y puede leer desde cuatro partes de un request HTTP:
+
+- Parámetros de path de URL
+- Parámetros de query de URL
+- Headers
+- Body del request
+
+## Binding con tags de struct
+
+Define un struct con tags que especifican el origen de datos y la clave, y luego llama a `c.Bind()`
+con un puntero a él. Aquí el parámetro de query `id` se vincula al campo `ID`:
+
+```go
+type User struct {
+	ID string `query:"id"`
+}
+
+// handler for /users?id=<userID>
+var user User
+if err := c.Bind(&user); err != nil {
+	return c.String(http.StatusBadRequest, "bad request")
+}
+```
+
+### Orígenes de datos
+
+| Tag      | Origen |
+| -------- | ------ |
+| `query`  | Parámetro de query |
+| `param`  | Parámetro de path |
+| `header` | Valor de header |
+| `form`   | Datos de formulario (query + body) |
+| `json`   | Body del request (`encoding/json`) |
+| `xml`    | Body del request (`encoding/xml`) |
+
+Los campos de path, query, header y form requieren un **tag explícito**. JSON y XML usan
+el nombre del campo del struct cuando se omite el tag, igual que la biblioteca estándar.
+
+### Content types del body
+
+Al decodificar el body del request, el header `Content-Type` selecciona el decoder:
+
+- `application/json`
+- `application/xml`
+- `application/x-www-form-urlencoded`
+
+### Múltiples orígenes y precedencia
+
+Un campo puede declarar varios orígenes. Los datos se vinculan en este orden, y cada paso
+sobrescribe el anterior:
+
+1. Parámetros de path
+2. Parámetros de query (solo GET / DELETE)
+3. Body del request
+
+```go
+type User struct {
+	ID string `param:"id" query:"id" form:"id" json:"id" xml:"id"`
+}
+```
+
+### Binding directo desde un origen
+
+```go
+echo.BindBody(c, &payload)        // request body
+echo.BindQueryParams(c, &payload) // query parameters
+echo.BindPathValues(c, &payload)  // path parameters
+echo.BindHeaders(c, &payload)     // headers
+```
+
+:::note
+Los headers **no** están incluidos por `c.Bind()`. Vincúlalos directamente con `echo.BindHeaders`.
+:::
+
+:::caution[Seguridad]
+No vincules directamente a structs de negocio. Si un struct vinculado expone un campo `IsAdmin bool`,
+un body de request `{"IsAdmin": true}` lo establecería. Usa un DTO dedicado y mapéalo explícitamente:
+:::
+
+```go
+type UserDTO struct {
+	Name  string `json:"name" form:"name" query:"name"`
+	Email string `json:"email" form:"email" query:"email"`
+}
+
+e.POST("/users", func(c *echo.Context) error {
+	var dto UserDTO
+	if err := c.Bind(&dto); err != nil {
+		return c.String(http.StatusBadRequest, "bad request")
+	}
+	user := User{Name: dto.Name, Email: dto.Email, IsAdmin: false}
+	executeSomeBusinessLogic(user)
+	return c.JSON(http.StatusOK, user)
+})
+```
+
+## Binding fluido
+
+Para binding explícito y type-safe desde un único origen, usa los binders fluidos. Encadenan
+la configuración y la ejecutan, recopilando errores:
+
+```go
+// /api/search?active=true&id=1&id=2&id=3&length=25
+var opts struct {
+	IDs    []int64
+	Active bool
+}
+length := int64(50)
+
+err := echo.QueryParamsBinder(c).
+	Int64("length", &length).
+	Int64s("id", &opts.IDs).
+	Bool("active", &opts.Active).
+	BindError() // first error, if any
+```
+
+Binders disponibles: `echo.QueryParamsBinder(c)`, `echo.PathValuesBinder(c)`,
+`echo.FormFieldBinder(c)`. Termina una cadena con `BindError()` (primer error) o
+`BindErrors()` (todos los errores). `FailFast(false)` ejecuta toda la cadena; está activado por defecto.
+
+Cada tipo soportado ofrece métodos `Type(...)`, `MustType(...)`, `Types(...)` (slices) y
+`MustTypes(...)`, por ejemplo `Int64`, `MustInt64`, `Int64s`. Usa
+`BindWithDelimiter("id", &dest, ",")` para separar valores unidos por comas.
+
+## Binder personalizado
+
+Registra un binder personalizado mediante `Echo#Binder`:
+
+```go
+type CustomBinder struct{}
+
+func (cb *CustomBinder) Bind(c *echo.Context, i any) error {
+	db := new(echo.DefaultBinder)
+	if err := db.Bind(c, i); err != echo.ErrUnsupportedMediaType {
+		return err
+	}
+	// custom logic here
+	return nil
+}
+
+e.Binder = &CustomBinder{}
+```

site/src/content/docs/es/guide/context.md

@@ -0,0 +1,78 @@
+---
+title: Context
+description: El objeto por request que transporta request, response, params y helpers.
+sidebar:
+  order: 4
+---
+
+`echo.Context` representa el contexto del request HTTP actual. Se pasa un puntero a él
+(`*echo.Context`) a cada handler y middleware, y transporta el request y response,
+parámetros de path, datos vinculados y helpers para construir responses.
+
+```go
+func handler(c *echo.Context) error {
+	// ...
+	return nil
+}
+```
+
+## Leer entrada
+
+```go
+id := c.Param("id")            // path parameter
+q := c.QueryParam("q")         // query string value
+all := c.QueryParams()         // url.Values of all query params
+name := c.FormValue("name")    // form field (URL + body)
+ua := c.Request().Header.Get(echo.HeaderUserAgent)
+```
+
+Hay helpers `*Or` equivalentes que devuelven un valor por defecto cuando el valor no está presente:
+`c.ParamOr("id", "0")`, `c.QueryParamOr("page", "1")`, `c.FormValueOr(...)`.
+
+## Escribir responses
+
+```go
+c.String(http.StatusOK, "plain text")
+c.JSON(http.StatusOK, payload)
+c.JSONPretty(http.StatusOK, payload, "  ")
+c.HTML(http.StatusOK, "<b>hi</b>")
+c.XML(http.StatusOK, payload)
+c.Blob(http.StatusOK, "application/pdf", bytes)
+c.Stream(http.StatusOK, "application/octet-stream", reader)
+c.NoContent(http.StatusNoContent)
+c.Redirect(http.StatusFound, "/elsewhere")
+```
+
+## Archivos
+
+```go
+c.File("public/report.pdf")             // serve a file
+c.Attachment("invoice.pdf", "inv.pdf")  // prompt download
+c.Inline("photo.png", "photo.png")      // render inline
+```
+
+## Almacenamiento por request
+
+Comparte datos entre middleware y handlers con `Get`/`Set`:
+
+```go
+c.Set("user", u)
+u, _ := c.Get("user").(*User)
+```
+
+El acceso tipado está disponible mediante los helpers genéricos:
+
+```go
+u, err := echo.ContextGet[*User](c, "user")
+```
+
+## Binding y validación
+
+`c.Bind()` analiza datos del request en un struct; consulta [Binding](/es/guide/binding/).
+
+```go
+var dto CreateUser
+if err := c.Bind(&dto); err != nil {
+	return echo.ErrBadRequest
+}
+```

site/src/content/docs/es/guide/cookies.md

@@ -0,0 +1,72 @@
+---
+title: Cookies
+description: Crea, lee y lista HTTP cookies usando el tipo estándar http.Cookie.
+sidebar:
+  order: 11
+---
+
+Una cookie es una pequeña pieza de datos que un servidor envía al navegador, que el navegador
+almacena y vuelve a enviar en requests posteriores. Las cookies permiten que los sitios web
+recuerden información con estado, como un carrito de compras, el estado de autenticación o
+valores de formularios ingresados previamente.
+
+Echo usa el tipo estándar `http.Cookie` de Go para agregar y obtener cookies desde
+`echo.Context` en un handler.
+
+## Atributos de Cookie
+
+| Atributo   | Opcional |
+| ---------- | -------- |
+| `Name`     | No       |
+| `Value`    | No       |
+| `Path`     | Sí       |
+| `Domain`   | Sí       |
+| `Expires`  | Sí       |
+| `Secure`   | Sí       |
+| `HttpOnly` | Sí       |
+
+## Crear una cookie
+
+```go
+func writeCookie(c *echo.Context) error {
+	cookie := new(http.Cookie)
+	cookie.Name = "username"
+	cookie.Value = "jon"
+	cookie.Expires = time.Now().Add(24 * time.Hour)
+	c.SetCookie(cookie)
+	return c.String(http.StatusOK, "write a cookie")
+}
+```
+
+- Crea la cookie con `new(http.Cookie)`.
+- Establece atributos en los campos de `http.Cookie`.
+- Llama a `c.SetCookie(cookie)` para agregar un header `Set-Cookie` a la response.
+
+## Leer una cookie
+
+```go
+func readCookie(c *echo.Context) error {
+	cookie, err := c.Cookie("username")
+	if err != nil {
+		return err
+	}
+	fmt.Println(cookie.Name)
+	fmt.Println(cookie.Value)
+	return c.String(http.StatusOK, "read a cookie")
+}
+```
+
+- Lee una cookie por nombre con `c.Cookie("username")`.
+- Accede a sus atributos mediante los campos de `http.Cookie`.
+
+## Leer todas las cookies
+
+```go
+func readAllCookies(c *echo.Context) error {
+	for _, cookie := range c.Cookies() {
+		fmt.Println(cookie.Name)
+		fmt.Println(cookie.Value)
+	}
+	return c.String(http.StatusOK, "read all the cookies")
+}
+```

site/src/content/docs/es/guide/customization.md

@@ -0,0 +1,62 @@
+---
+title: Personalización
+description: Personaliza el logger, validator, binder, renderer, serializer y manejo de errores de Echo.
+sidebar:
+  order: 12
+---
+
+Echo expone un conjunto de campos en la instancia `Echo` que te permiten reemplazar el
+comportamiento integrado con tus propias implementaciones.
+
+## Logging
+
+`Echo#Logger` escribe logs estructurados. El handler por defecto emite JSON a `os.Stdout`.
+
+### Logger personalizado
+
+El logger es un `*slog.Logger`, por lo que puedes registrar cualquier handler de `slog`:
+
+```go
+e.Logger = slog.New(slog.NewJSONHandler(os.Stdout, nil))
+```
+
+## Validator
+
+`Echo#Validator` registra un validator para validar payloads de request.
+
+[Aprende más](/es/guide/request/#validate-data)
+
+## Binder personalizado
+
+`Echo#Binder` registra un binder personalizado para binding de payloads de request.
+
+[Aprende más](/es/guide/binding/#custom-binder)
+
+## Serializer JSON personalizado
+
+`Echo#JSONSerializer` registra un serializer JSON personalizado. Consulta `DefaultJSONSerializer`
+en [json.go](https://github.com/labstack/echo/blob/master/json.go).
+
+## Renderer
+
+`Echo#Renderer` registra un renderer para renderizado de templates.
+
+[Aprende más](/es/guide/templates/)
+
+## Handler de errores HTTP
+
+`Echo#HTTPErrorHandler` registra un handler de errores HTTP personalizado.
+
+[Aprende más](/es/guide/error-handling/)
+
+## Callback de ruta
+
+`Echo#OnAddRoute` registra un callback que se invoca cada vez que se agrega una nueva ruta al
+router.
+
+## Extractor de IP
+
+`Echo#IPExtractor` controla cómo se determina la dirección IP real del cliente. Para
+obtenerla de forma fiable y segura, tu aplicación debe conocer toda su infraestructura.
+
+[Aprende más](/es/guide/ip-address/)