Imagina construir una casa sin planos. Cada habitación dependería de las otras, los cables se cruzarían, y cualquier cambio requeriría demoler paredes. En el desarrollo de software, especialmente en TypeScript, enfrentamos el mismo problema cuando gestionamos dependencias. Las Layers de Effect-TS son nuestros planos arquitectónicos modernos. 🗺️

¿Qué son realmente las Layers?

Las Layers en Effect-TS son como plantillas de construcción para servicios. No son simplemente una forma de organizar código; son una metodología de diseño que permite construir aplicaciones robustas, testeables y mantenibles. ✅

Las capaz son como templates de servicios. 😳

De la Teoría a la Práctica

1. Definiendo Nuestros servicios

Primero, definimos qué necesitamos que haga cada servicio:

interface EmailService {
  send: (to: string, subject: string, body: string) => Effect.Effect<void, Error>
}

interface DatabaseService {
  saveUser: (user: User) => Effect.Effect<User, Error>
  findUser: (id: string) => Effect.Effect<User | null, Error>
}

interface LoggerService {
  info: (message: string) => Effect.Effect<void>
  error: (message: string) => Effect.Effect<void>
}

2. Creando las "Plantillas de Instalación"

Ahora creamos las capas que nos dicen cómo construir cada servicio:

// Capa para el servicio de email
const EmailLive = Layer.effect(
  EmailService,
  Effect.gen(function*() {
    const config = yield* ConfigService
    const apiKey = config.emailApiKey

    return EmailService.of({
      send: (to, subject, body) =>
        Effect.tryPromise({
          try: () => sendEmailViaAPI(apiKey, to, subject, body),
          catch: (error) => new EmailError(error.message)
        })
    })
  })
)

// Capa para el servicio de base de datos
const DatabaseLive = Layer.scoped(
  DatabaseService,
  Effect.acquireRelease(
    Effect.tryPromise({
      try: () => createDatabaseConnection(process.env.DATABASE_URL),
      catch: (error) => new DatabaseError(error.message)
    }),
    (connection) => Effect.sync(() => connection.close())
  )
)

3. Componiendo el Sistema Completo

Las capas se pueden combinar como piezas de LEGO:

// Capa base con configuración
const ConfigLive = Layer.succeed(
  ConfigService,
  ConfigService.of({
    emailApiKey: process.env.EMAIL_API_KEY!,
    databaseUrl: process.env.DATABASE_URL!
  })
)

// Sistema completo
const AppLayer = ConfigLive.pipe(
  Layer.provideMerge(LoggerLive),
  Layer.provideMerge(DatabaseLive),
  Layer.provideMerge(EmailLive)
)

El Poder de la Composición

Escenarios de Uso Real

1. Testing sin Mocks Complicados

// Test Layer - reemplaza solo lo necesario
const TestLayer = Layer.succeed(
  EmailService,
  EmailService.of({
    send: () => Effect.succeed(undefined) // No envía emails reales
  })
)

// Ejecutar tests con capas de test
const testResult = await Effect.runPromise(
  Effect.provide(program, TestLayer)
)

2. Desarrollo Local vs Producción

// Configuración por ambiente
const getAppLayer = (env: 'dev' | 'prod') => {
  return env === 'prod'
    ? ProductionLayer
    : DevelopmentLayer
}

Mejores Prácticas Profesionales

1. Separación de Responsabilidades

// ❌ Mal: Todo en una capa gigante
const EverythingLayer = Layer.effect(...)

// ✅ Bien: Capas pequeñas y enfocadas
const DatabaseLayer = Layer.effect(...)
const CacheLayer = Layer.effect(...)
const ValidationLayer = Layer.effect(...)

2. Manejo de Recursos

// ✅ Correcto: Liberación automática de recursos
const DatabaseLayer = Layer.scoped(
  DatabaseService,
  Effect.acquireRelease(
    createConnection,
    (conn) => Effect.sync(() => conn.close())
  )
)

3. Composición Clara

// ✅ Orden lógico y legible
const AppLayer = ConfigLayer.pipe(
  Layer.provideMerge(LoggerLayer),
  Layer.provideMerge(DatabaseLayer),
  Layer.provideMerge(CacheLayer)
)

Conclusión

Las Layers en Effect-TS no son solo una herramienta; son una filosofía de diseño que transforma la forma de construir aplicaciones. Al adoptar este enfoque, obtienes:

• Aplicaciones más mantenibles
• Tests más simples y confiables
• Desarrollo más rápido y seguro
• Código que escala con tu negocio

El futuro del desarrollo TypeScript está en la composición declarativa, y las Layers son tu puerta de entrada a este nuevo paradigma.

---

¿Listo para transformar tu arquitectura? Comienza con una pequeña capa hoy y observa cómo tu código se vuelve más limpio y predecible. Comparte con tus amigos. 🥸

Abrazo. Bliss. 🤓