@saulwade/swl-ses 1.0.0

package/reglas/lenguajes/swift/patrones.md

@@ -0,0 +1,235 @@
+# Regla: Patrones de Arquitectura Swift / iOS
+
+Esta regla define los patrones obligatorios para estructurar código Swift en iOS.
+La orientación a protocolos, MVVM con `@Observable` y la concurrencia estructurada
+son el estándar para proyectos nuevos con Swift 5.9+.
+
+---
+
+## Protocol-oriented programming sobre herencia
+
+Swift favorece composición de protocolos sobre jerarquías de herencia profundas.
+Los protocolos definen capacidades; los tipos las adoptan independientemente.
+
+```swift
+// MAL — jerarquía de herencia que crece y se vuelve frágil
+class Animal { func hacerSonido() {} }
+class Perro: Animal { override func hacerSonido() { } }
+class PerroGuardian: Perro { /* dependencia de toda la cadena */ }
+
+// BIEN — protocolos que componen capacidades independientes
+protocol Localizable {
+    var coordenadas: CLLocationCoordinate2D { get }
+}
+
+protocol Notificable {
+    func enviarAlerta(_ mensaje: String) async
+}
+
+struct DispositivoIoT: Localizable, Notificable {
+    let coordenadas: CLLocationCoordinate2D
+    func enviarAlerta(_ mensaje: String) async { ... }
+}
+```
+
+---
+
+## Dependency injection via protocolos
+
+Las dependencias se declaran como protocolos. En producción se inyectan implementaciones
+reales; en tests, mocks. Nunca instanciar dependencias dentro de un tipo.
+
+```swift
+// Protocolo en la capa de dominio
+protocol PedidoRepository {
+    func obtenerPorId(_ id: UUID) async throws -> Pedido
+    func guardar(_ pedido: Pedido) async throws
+}
+
+// ViewModel recibe el protocolo — no sabe si es real o mock
+@Observable
+final class PedidoViewModel {
+    private let repositorio: PedidoRepository
+
+    init(repositorio: PedidoRepository) {
+        self.repositorio = repositorio
+    }
+}
+
+// En produccion
+let vm = PedidoViewModel(repositorio: PedidoRepositoryImpl(apiClient: client))
+
+// En tests
+let vm = PedidoViewModel(repositorio: MockPedidoRepository())
+```
+
+---
+
+## MVVM con @Observable (iOS 17+)
+
+`@Observable` (macro de Swift 5.9+) reemplaza `ObservableObject` + `@Published`.
+Elimina boilerplate y mejora el rendimiento de SwiftUI al rastrear solo las
+propiedades realmente accedidas en cada vista.
+
+```swift
+// MAL — ObservableObject con @Published (iOS 16 y anterior)
+class PedidoViewModel: ObservableObject {
+    @Published var pedidos: [Pedido] = []
+    @Published var isLoading = false
+    @Published var error: String?
+}
+
+// BIEN — @Observable: mas limpio, mejor rendimiento de recomposicion
+@Observable
+final class PedidoViewModel {
+    var pedidos: [Pedido] = []
+    var isLoading = false
+    var error: String?
+    private let repositorio: PedidoRepository
+
+    init(repositorio: PedidoRepository) {
+        self.repositorio = repositorio
+    }
+
+    func cargarPedidos() async {
+        isLoading = true
+        defer { isLoading = false }
+        do {
+            pedidos = try await repositorio.obtenerTodos()
+        } catch {
+            self.error = error.localizedDescription
+        }
+    }
+}
+
+// Vista — limpia, sin @StateObject/@ObservedObject
+struct PantallaPedidos: View {
+    @State private var viewModel = PedidoViewModel(repositorio: ...)
+
+    var body: some View {
+        Group {
+            if viewModel.isLoading { ProgressView() }
+            else { ListaPedidos(pedidos: viewModel.pedidos) }
+        }
+        .task { await viewModel.cargarPedidos() }
+    }
+}
+```
+
+---
+
+## NavigationStack con NavigationPath para navegación programática
+
+```swift
+// MAL — NavigationView deprecado en iOS 16+
+NavigationView {
+    NavigationLink("Ver detalle", destination: DetallePedidoView())
+}
+
+// BIEN — NavigationStack con rutas tipadas
+enum RutaApp: Hashable {
+    case detallePedido(UUID)
+    case editarPerfil
+}
+
+struct AppRootView: View {
+    @State private var ruta = NavigationPath()
+
+    var body: some View {
+        NavigationStack(path: $ruta) {
+            ListaPedidosView(onSeleccion: { id in
+                ruta.append(RutaApp.detallePedido(id))
+            })
+            .navigationDestination(for: RutaApp.self) { ruta in
+                switch ruta {
+                case .detallePedido(let id): DetallePedidoView(pedidoId: id)
+                case .editarPerfil: EditarPerfilView()
+                }
+            }
+        }
+    }
+}
+```
+
+---
+
+## SwiftUI: @State, @Binding, @Environment
+
+```swift
+// @State — estado local del componente, no se comparte hacia arriba
+struct ContadorView: View {
+    @State private var contador = 0
+    var body: some View {
+        Button("Contar: \(contador)") { contador += 1 }
+    }
+}
+
+// @Binding — estado que viene del padre, el hijo puede modificarlo
+struct SelectorFecha: View {
+    @Binding var fecha: Date
+    var body: some View {
+        DatePicker("Fecha", selection: $fecha, displayedComponents: .date)
+    }
+}
+
+// @Environment — dependencias globales inyectadas por SwiftUI
+struct Vista: View {
+    @Environment(\.colorScheme) private var colorScheme
+    @Environment(GestorAutenticacion.self) private var auth
+}
+```
+
+---
+
+## Ejemplo: Massive ViewController vs MVVM
+
+```swift
+// MAL — UIViewController con 500+ líneas que hace todo
+class PedidosViewController: UIViewController {
+    private var pedidos: [Pedido] = []
+
+    override func viewDidLoad() {
+        super.viewDidLoad()
+        URLSession.shared.dataTask(with: url) { data, _, error in
+            guard let data = data else { return }
+            self.pedidos = try! JSONDecoder().decode([Pedido].self, from: data)
+            DispatchQueue.main.async { self.tableView.reloadData() }
+        }.resume()
+    }
+    // ... 400 líneas más de UITableViewDataSource, lógica de negocio, formato, etc.
+}
+
+// BIEN — MVVM con responsabilidades separadas
+@Observable
+final class PedidosViewModel {
+    private(set) var pedidos: [Pedido] = []
+    private(set) var isLoading = false
+    private let repositorio: PedidoRepository
+
+    func cargar() async {
+        isLoading = true
+        defer { isLoading = false }
+        pedidos = (try? await repositorio.obtenerTodos()) ?? []
+    }
+}
+
+struct PedidosView: View {
+    @State private var vm = PedidosViewModel(repositorio: PedidoRepositoryImpl())
+    var body: some View {
+        List(vm.pedidos) { pedido in FilaPedido(pedido: pedido) }
+            .task { await vm.cargar() }
+    }
+}
+```
+
+---
+
+## Checklist de patrones Swift antes de abrir PR
+
+- [ ] Dependencias declaradas como protocolos, inyectadas en el inicializador
+- [ ] ViewModels usan `@Observable` (iOS 17+) o `ObservableObject` (iOS 16-)
+- [ ] Sin lógica de negocio en vistas SwiftUI (va en ViewModel o use case)
+- [ ] Navegación con `NavigationStack` y rutas tipadas
+- [ ] Concurrencia con `async/await`; actores para estado compartido
+- [ ] Sin `Massive ViewController`: UIKit con MVVM si se usa UIKit
+- [ ] Protocolos para composicion de capacidades, no herencia profunda

package/reglas/lenguajes/swift/seguridad.md

@@ -0,0 +1,248 @@
+# Regla: Seguridad en Swift / iOS
+
+Esta regla es OBLIGATORIA para todo código Swift en iOS.
+iOS tiene mecanismos de seguridad de primera clase — el error más común es no usarlos
+y recurrir a soluciones inseguras por conveniencia (UserDefaults para tokens, HTTP sin ATS).
+
+---
+
+## Keychain Services para secretos: nunca UserDefaults
+
+`UserDefaults` es un plist sin cifrado. Cualquier proceso con acceso al sandbox
+puede leerlo. Los secretos (tokens, credenciales, claves privadas) van en Keychain.
+
+```swift
+// MAL — token en texto plano
+UserDefaults.standard.set(accessToken, forKey: "access_token")
+
+// BIEN — Keychain con accesibilidad adecuada
+import Security
+
+struct KeychainManager {
+    static func guardar(_ valor: String, para clave: String) throws {
+        let data = Data(valor.utf8)
+        let query: [String: Any] = [
+            kSecClass as String:              kSecClassGenericPassword,
+            kSecAttrAccount as String:        clave,
+            kSecValueData as String:          data,
+            kSecAttrAccessible as String:     kSecAttrAccessibleWhenUnlockedThisDeviceOnly,
+        ]
+        SecItemDelete(query as CFDictionary)
+        let estado = SecItemAdd(query as CFDictionary, nil)
+        guard estado == errSecSuccess else {
+            throw KeychainError.escrituraFallida(estado)
+        }
+    }
+
+    static func obtener(_ clave: String) throws -> String? {
+        let query: [String: Any] = [
+            kSecClass as String:              kSecClassGenericPassword,
+            kSecAttrAccount as String:        clave,
+            kSecReturnData as String:         true,
+            kSecMatchLimit as String:         kSecMatchLimitOne,
+        ]
+        var resultado: CFTypeRef?
+        let estado = SecItemCopyMatching(query as CFDictionary, &resultado)
+        guard estado == errSecSuccess, let data = resultado as? Data else { return nil }
+        return String(data: data, encoding: .utf8)
+    }
+}
+```
+
+Usar `kSecAttrAccessibleWhenUnlockedThisDeviceOnly` para datos que no deben
+sincronizarse con iCloud Keychain ni estar disponibles cuando el dispositivo está bloqueado.
+
+---
+
+## App Transport Security (ATS) siempre habilitado
+
+ATS fuerza conexiones HTTPS. No desactivarlo en producción. Nunca.
+
+```xml
+<!-- Info.plist — CORRECTO: ATS habilitado por defecto -->
+<!-- No se necesita ningún key de NSAppTransportSecurity para el caso normal -->
+
+<!-- MAL — desactivar ATS completamente -->
+<key>NSAppTransportSecurity</key>
+<dict>
+    <key>NSAllowsArbitraryLoads</key>
+    <true/>
+</dict>
+
+<!-- ACEPTABLE — excepción para un dominio específico con justificación documentada -->
+<key>NSAppTransportSecurity</key>
+<dict>
+    <key>NSExceptionDomains</key>
+    <dict>
+        <key>legacy-api.empresa.com</key>
+        <dict>
+            <key>NSExceptionAllowsInsecureHTTPLoads</key>
+            <true/>
+        </dict>
+    </dict>
+</dict>
+```
+
+Si se necesita una excepción para la App Store, Apple requiere justificación.
+Documentar en el ADR por qué el dominio no puede usar HTTPS.
+
+---
+
+## Certificate Pinning con URLSession
+
+```swift
+// BIEN — delegate de URLSession para validar el certificado
+final class PinningURLSessionDelegate: NSObject, URLSessionDelegate {
+    private let hashesEsperados: Set<String>
+
+    init(hashesEsperados: Set<String>) {
+        self.hashesEsperados = hashesEsperados
+    }
+
+    func urlSession(
+        _ session: URLSession,
+        didReceive challenge: URLAuthenticationChallenge,
+        completionHandler: @escaping (URLSession.AuthChallengeDisposition, URLCredential?) -> Void
+    ) {
+        guard challenge.protectionSpace.authenticationMethod == NSURLAuthenticationMethodServerTrust,
+              let serverTrust = challenge.protectionSpace.serverTrust,
+              let certificado = SecTrustGetCertificateAtIndex(serverTrust, 0) else {
+            completionHandler(.cancelAuthenticationChallenge, nil)
+            return
+        }
+
+        let dataPublicKey = SecCertificateCopyData(certificado) as Data
+        let hashActual = SHA256.hash(data: dataPublicKey)
+            .map { String(format: "%02x", $0) }.joined()
+
+        if hashesEsperados.contains(hashActual) {
+            completionHandler(.useCredential, URLCredential(trust: serverTrust))
+        } else {
+            completionHandler(.cancelAuthenticationChallenge, nil)
+        }
+    }
+}
+
+// Uso
+let session = URLSession(
+    configuration: .default,
+    delegate: PinningURLSessionDelegate(hashesEsperados: ["abc123...", "def456..."]),
+    delegateQueue: nil
+)
+```
+
+Incluir siempre al menos dos hashes (certificado actual + respaldo) para permitir
+rotación sin dejar la app sin servicio.
+
+---
+
+## Data Protection API para archivos sensibles
+
+```swift
+// BIEN — archivos con protección máxima: solo accesibles cuando desbloqueado
+func guardarArchivoSeguro(datos: Data, nombre: String) throws {
+    let url = FileManager.default
+        .urls(for: .documentDirectory, in: .userDomainMask)[0]
+        .appendingPathComponent(nombre)
+
+    try datos.write(to: url, options: [.completeFileProtection])
+    // .completeFileProtection = solo accesible con dispositivo desbloqueado
+    // .completeFileProtectionUnlessOpen = accesible mientras el archivo está abierto
+}
+```
+
+Verificar en la entitlements que `Data Protection` está en `NSFileProtectionComplete`.
+
+---
+
+## Autenticación biométrica con LocalAuthentication
+
+```swift
+import LocalAuthentication
+
+func autenticarConBiometria() async -> Bool {
+    let contexto = LAContext()
+    var error: NSError?
+
+    guard contexto.canEvaluatePolicy(.deviceOwnerAuthenticationWithBiometrics, error: &error) else {
+        // Biometría no disponible — ofrecer PIN como alternativa
+        return await autenticarConPIN()
+    }
+
+    do {
+        return try await contexto.evaluatePolicy(
+            .deviceOwnerAuthenticationWithBiometrics,
+            localizedReason: "Confirma tu identidad para continuar"
+        )
+    } catch {
+        // No loguear el tipo de error LAError — puede revelar información de intentos fallidos
+        return false
+    }
+}
+```
+
+Usar `.deviceOwnerAuthentication` (biometría O PIN) en lugar de solo biometría
+para garantizar que el usuario siempre puede autenticarse aunque la biometría falle.
+
+---
+
+## No hardcodear API keys ni secretos
+
+```swift
+// MAL — la key queda en el binario y es extraíble con strings o Hopper
+let apiKey = "sk-prod-abc123def456"
+let urlBase = "https://api.servicio.com?key=\(apiKey)"
+
+// BIEN — la key se obtiene del servidor tras autenticacion del usuario
+// El cliente recibe un token de sesión, el servidor maneja las API keys de terceros
+struct ConfiguracionRemota {
+    var endpointApiGateway: URL
+    // Sin API keys de terceros aquí
+}
+```
+
+Para SDKs que requieren clave en el cliente (ej: Stripe publishable key, Firebase):
+- Usar Xcode Build Settings con `xcconfig` no versionado para distintos entornos
+- Nunca en el código fuente directamente
+
+---
+
+## Validación de deep links y universal links
+
+```swift
+// BIEN — validar scheme, host y parámetros antes de procesar
+func application(
+    _ app: UIApplication,
+    open url: URL,
+    options: [UIApplication.OpenURLOptionsKey: Any] = [:]
+) -> Bool {
+    guard url.scheme == "miapp",
+          url.host == "pedidos",
+          let componentes = URLComponents(url: url, resolvingAgainstBaseURL: false),
+          let parametroId = componentes.queryItems?.first(where: { $0.name == "id" })?.value,
+          let pedidoId = UUID(uuidString: parametroId) else {
+        // Log del intento inválido para auditoría, pero sin detalles del URL
+        logger.warning("Deep link inválido recibido")
+        return false
+    }
+
+    navegarADetallePedido(id: pedidoId)
+    return true
+}
+```
+
+Registrar intentos de deep links inválidos para detectar intentos de explotación.
+NUNCA usar los parámetros del URL directamente sin validar el tipo y el formato.
+
+---
+
+## Checklist de seguridad Swift antes de abrir PR
+
+- [ ] Sin secretos ni tokens en `UserDefaults` — usar Keychain
+- [ ] ATS habilitado: sin `NSAllowsArbitraryLoads` en producción
+- [ ] Certificate pinning configurado con hash de respaldo
+- [ ] Archivos sensibles con `Data Protection (.completeFileProtection)`
+- [ ] Autenticación biométrica usa `LocalAuthentication` framework
+- [ ] Sin API keys hardcodeadas en el código fuente
+- [ ] Deep links y universal links validados en scheme, host y parámetros
+- [ ] Code signing con provisioning profiles correctos para el ambiente