Spanish translation for advanced/middleware.es.md (#985)

<!-- 🚀 Thank you for contributing! -->

<!-- Describe your changes clearly and use examples if possible. -->
Added spanish translation for advanced/middleware.md file

<!-- When this PR is merged, the title and body will be -->
Spanish translation for advanced/middleware.es.md

<!-- used to generate a release automatically. -->

docs/advanced/middleware.es.md

@@ -0,0 +1,152 @@
+# Middleware
+
+Middleware es una cadena lógica entre el cliente y el controlador de ruta de Vapor. Le permite realizar operaciones en solicitudes entrantes antes de que lleguen al controlador de ruta y en respuestas antes de que lleguen al cliente. 
+
+## Configuración
+
+Middleware se puede registrar de forma global (en cada ruta) en la función `configure(_:)` usando `app.middleware`.
+
+```swift
+app.middleware.use(MyMiddleware())
+```
+
+También puedes añadir middleware a rutas individuales utilizando grupos de rutas.
+
+```swift
+let group = app.grouped(MyMiddleware())
+group.get("foo") { req in
+ // Esta solicitud ha pasado por MyMiddleware
+}
+```
+
+### Orden
+
+El orden en que se agrega middleware es importante. Solicitudes que ingresan a tu aplicación pasarán por el middleware en el orden en que se agregan. Las respuestas que salgan de tu aplicación pasarán de nuevo por el middleware en el orden inverso. El middleware específico de ruta siempre se ejecuta después del middleware de la aplicación. Tomemos el siguiente ejemplo:
+
+```swift
+app.middleware.use(MiddlewareA())
+app.middleware.use(MiddlewareB())
+
+app.group(MiddlewareC()) {
+ $0.get("hello") { req in
+ "Hello, middleware."
+ }
+}
+```
+
+Una solicitud `GET /hello` visitará el middleware en el siguiente orden:
+
+```
+Solicitud → A → B → C → Controlador → C → B → A → Respuesta
+```
+
+Middleware también puede ser _antepuesto_, lo cual es útil cuando desea agregar un middleware antes de que el middleware predeterminado se agregue automáticamente:
+
+```swift
+app.middleware.use(someMiddleware, at: .beginning)
+```
+
+## Creando un Middleware
+
+Vapor viene con algunos middlewares útiles, pero es posible que necesites crear el tuyo propio debido a los requisitos de tu aplicación. Por ejemplo, podrías crear un middleware que impida que cualquier usuario que no sea administrador acceda a un grupo de rutas.
+
+> Recomendamos crear una carpeta llamada `Middleware` dentro del directorio `Sources/App` para mantener tu codigo organizado
+
+Middleware son tipos que se ajustan al protocolo `Middleware` o `AsyncMiddleware` de Vapor. Se insertan en la cadena de respuesta y pueden acceder y manipular una solicitud antes de que llegue a un controlador de ruta y modificar una respuesta antes de que se devuelva.
+
+Usando el ejemplo mencionado anteriormente, cree un middleware para bloquear acceso al usuario si no es administrador:
+
+```swift
+import Vapor
+
+struct EnsureAdminUserMiddleware: Middleware {
+ func respond(to request: Request, chainingTo next: Responder) -> EventLoopFuture<Response> {
+ guard let user = request.auth.get(User.self), user.role == .admin else {
+ return request.eventLoop.future(error: Abort(.unauthorized))
+ }
+ return next.respond(to: request)
+ }
+}
+```
+
+O si estas usando `async`/`await` puedes escribir:
+
+```swift
+import Vapor
+
+struct EnsureAdminUserMiddleware: AsyncMiddleware {
+ func respond(to request: Request, chainingTo next: AsyncResponder) async throws -> Response {
+ guard let user = request.auth.get(User.self), user.role == .admin else {
+ throw Abort(.unauthorized)
+ }
+ return try await next.respond(to: request)
+ }
+}
+```
+
+Si deseas modificar la respuesta, por ejemplo, para añadir un cabecero personalizado, puedes usar un middleware para esto también. Middlewares pueden esperar hasta que la respuesta sea recibida por parte de la cadena de respuesta y manipular la respuesta:
+
+```swift
+import Vapor
+
+struct AddVersionHeaderMiddleware: Middleware {
+ func respond(to request: Request, chainingTo next: Responder) -> EventLoopFuture<Response> {
+ next.respond(to: request).map { response in
+ response.headers.add(name: "My-App-Version", value: "v2.5.9")
+ return response
+ }
+ }
+}
+```
+
+O si estas usando `async`/`await` puedes escribir:
+
+```swift
+import Vapor
+
+struct AddVersionHeaderMiddleware: AsyncMiddleware {
+ func respond(to request: Request, chainingTo next: AsyncResponder) async throws -> Response {
+ let response = try await next.respond(to: request)
+ response.headers.add(name: "My-App-Version", value: "v2.5.9")
+ return response
+ }
+}
+```
+
+## File Middleware
+
+`FileMiddleware` permite servir activos desde la carpeta pública de su proyecto al cliente. Puede incluir archivos estáticos como hojas de estilo o imágenes de mapa de bits.
+
+```swift
+let file = FileMiddleware(publicDirectory: app.directory.publicDirectory)
+app.middleware.use(file)
+```
+
+Una vez que `FileMiddleware` esté registrado, un archivo como `Public/images/logo.png` se puede vincular desde una plantilla Leaf como `<img src="/images/logo.png"/>`.
+
+Si tu servidor está almacenado en un projecto Xcode, como una applicación de iOS, use esto en su lugar:
+
+```swift
+let file = try FileMiddleware(bundle: .main, publicDirectory: "Public")
+```
+
+Tambien asegúrese de usar referencias de carpetas en lugar de grupos en Xcode para mantener la estructura de carpetas en los recursos despues de crear la applicación.
+
+## CORS Middleware
+
+El intercambio de recursos entre orígenes (CORS, por sus siglas en inglés) es un mecanismo que permite solicitar recursos restringidos en una página web desde otro dominio fuera del dominio desde el que se sirvió el primer recurso. Las API REST integradas en Vapor requerirán una política CORS para poder devolver solicitudes de forma segura a los navegadores web modernos.
+
+Una configuración de ejemplo podría verse así:
+
+```swift
+let corsConfiguration = CORSMiddleware.Configuration(
+ allowedOrigin: .all,
+ allowedMethods: [.GET, .POST, .PUT, .OPTIONS, .DELETE, .PATCH],
+ allowedHeaders: [.accept, .authorization, .contentType, .origin, .xRequestedWith, .userAgent, .accessControlAllowOrigin]
+)
+let cors = CORSMiddleware(configuration: corsConfiguration)
+// cors middleware debería aparecer antes del middleware de error predeterminado usando `at: .beginning`
+app.middleware.use(cors, at: .beginning)
+```
+
+Dado que los errores generados se devuelven inmediatamente al cliente, `CORSMiddleware` debe aparecer antes de `ErrorMiddleware`. De lo contrario, la respuesta de error HTTP se devolverá sin encabezados CORS y el navegador no podrá leerla.