@icarusmx/creta 1.3.4 → 1.3.5

package/lib/data/lessons/lesson6-interface-design.js

@@ -0,0 +1,407 @@
+export const LESSON_6_INTERFACE_DESIGN = {
+  id: 6,
+  title: 'LECCIÓN 6: El énfasis al diseñar los objetos debe estar en la definición de sus solicitudes e interfaces',
+  subtitle: 'Enfoque práctico: Sistema bancario con diseño interface-first y encapsulación',
+  flow: [
+    {
+      lines: [
+        '\n💡 ¿Por qué es importante?',
+        '- Las interfaces definen QUÉ hace un objeto, no CÓMO lo hace',
+        '- Facilita la colaboración entre objetos',
+        '- Permite cambiar implementaciones sin afectar otros objetos',
+        '- Hace el código más mantenible y extensible'
+      ],
+      type: 'text'
+    },
+    {
+      message: '\nPresiona Enter para comenzar el ejercicio práctico...',
+      type: 'pause'
+    },
+    {
+      type: 'clear'
+    },
+    {
+      lines: [
+        '🛠️ EJERCICIO PRÁCTICO: Sistema Bancario',
+        '==================================================',
+        '🎯 Objetivo: Diseñar interfaces ANTES de implementar',
+        '\nVamos a crear un sistema bancario donde:',
+        '- BankAccount representa una cuenta con balance privado',
+        '- Transaction registra movimientos entre cuentas',
+        '- Bank gestiona múltiples cuentas y validaciones'
+      ],
+      type: 'text'
+    },
+    {
+      message: '\nPresiona Enter para ver cómo diseñar las interfaces...',
+      type: 'pause'
+    },
+    {
+      type: 'clear'
+    },
+    {
+      lines: [
+        '📋 PASO 1: Definir las Solicitudes',
+        '========================================',
+        'Antes de escribir código, pensemos: ¿Qué solicitudes debe manejar cada objeto?',
+        '\n🏦 BankAccount debe poder:',
+        '  - Consultar balance (sin exponer el dato interno)',
+        '  - Recibir dinero (depósito)',
+        '  - Enviar dinero (con validación interna)',
+        '  - Proporcionar información de la cuenta',
+        '\n📊 Transaction debe poder:',
+        '  - Registrar origen, destino y monto',
+        '  - Proporcionar detalles del movimiento',
+        '  - Validar si la transacción es válida',
+        '\n🏛️ Bank debe poder:',
+        '  - Crear nuevas cuentas',
+        '  - Procesar transferencias entre cuentas',
+        '  - Validar operaciones antes de ejecutarlas',
+        '  - Llevar registro de todas las transacciones'
+      ],
+      type: 'text'
+    },
+    {
+      message: '\n' +
+        '✅ ¡Excelente! Ya definimos QUÉ debe hacer cada objeto. Presiona Enter para definir las interfaces...',
+      type: 'pause'
+    },
+    {
+      type: 'clear'
+    },
+    {
+      lines: [
+        '🔌 PASO 2: Definir las Interfaces (Firmas de Operación)',
+        '==================================================',
+        'Ahora especifiquemos CÓMO se solicitan estas operaciones:',
+        '\n// BankAccount Interface',
+        'class BankAccount {',
+        '  constructor(accountNumber, ownerName, initialBalance) → BankAccount',
+        '  getBalance() → number              // ⚠️ ENCAPSULACIÓN: acceso controlado',
+        '  getAccountInfo() → {number, owner, balance}',
+        '  deposit(amount) → boolean',
+        '  send(amount, targetAccount) → boolean  // ⚠️ VALIDACIÓN interna',
+        '}',
+        '\n// Transaction Interface',
+        'class Transaction {',
+        '  constructor(from, to, amount, timestamp) → Transaction',
+        '  getDetails() → {from, to, amount, timestamp, status}',
+        '  isValid() → boolean',
+        '}',
+        '\n// Bank Interface',
+        'class Bank {',
+        '  createAccount(ownerName, initialBalance) → BankAccount',
+        '  transfer(fromAccount, toAccount, amount) → Transaction',
+        '  getAllTransactions() → Array<Transaction>',
+        '  validateOperation(account, amount) → boolean',
+        '}',
+        '\n💡 Observa que cada operación especifica:',
+        '   a) Nombre de la operación (getBalance, send, transfer, etc.)',
+        '   b) Insumos necesarios (amount, targetAccount, etc.)',
+        '   c) Valor que regresa (boolean, Transaction, etc.)',
+        '\n' +
+          '🔒 Nota especial: getBalance() encapsula el acceso al estado interno',
+        '🛡️  Nota especial: send() incluirá validación antes de ejecutar'
+      ],
+      type: 'text'
+    },
+    {
+      message: '\n✅ Interfaces definidas. Presiona Enter para implementar...',
+      type: 'pause'
+    },
+    {
+      type: 'clear'
+    },
+    {
+      lines: [
+        '⚙️ PASO 3: Implementar los Objetos',
+        '========================================',
+        'Ahora que tenemos las interfaces claras, implementemos:',
+        '\n// Implementación de BankAccount',
+        'class BankAccount {\n' +
+          '  constructor(accountNumber, ownerName, initialBalance) {\n' +
+          '    this.accountNumber = accountNumber\n' +
+          '    this.ownerName = ownerName\n' +
+          '    this.#balance = initialBalance  // 🔒 PRIVADO: no se accede directamente\n' +
+          '  }\n' +
+          '\n' +
+          '  // 🔑 ENCAPSULACIÓN: método GET para acceder al balance\n' +
+          '  getBalance() {\n' +
+          '    return this.#balance\n' +
+          '  }\n' +
+          '\n' +
+          '  getAccountInfo() {\n' +
+          '    return {\n' +
+          '      number: this.accountNumber,\n' +
+          '      owner: this.ownerName,\n' +
+          '      balance: this.#balance  // Controlamos qué se expone\n' +
+          '    }\n' +
+          '  }\n' +
+          '\n' +
+          '  deposit(amount) {\n' +
+          '    if (amount > 0) {\n' +
+          '      this.#balance += amount\n' +
+          '      return true\n' +
+          '    }\n' +
+          '    return false\n' +
+          '  }\n' +
+          '\n' +
+          '  // 🛡️ VALIDACIÓN: método SEND con lógica interna\n' +
+          '  send(amount, targetAccount) {\n' +
+          '    // Validación interna ANTES de ejecutar\n' +
+          '    if (amount > 0 && this.#balance >= amount) {\n' +
+          '      this.#balance -= amount\n' +
+          '      targetAccount.deposit(amount)\n' +
+          '      return true\n' +
+          '    }\n' +
+          '    return false  // Fondos insuficientes o monto inválido\n' +
+          '  }\n' +
+          '}'
+      ],
+      type: 'text'
+    },
+    {
+      message: '\nPresiona Enter para ver Transaction...',
+      type: 'pause'
+    },
+    {
+      lines: [
+        '\n// Implementación de Transaction',
+        'class Transaction {\n' +
+          '  constructor(fromAccount, toAccount, amount) {\n' +
+          '    this.fromAccount = fromAccount\n' +
+          '    this.toAccount = toAccount\n' +
+          '    this.amount = amount\n' +
+          '    this.timestamp = new Date()\n' +
+          "    this.status = 'pending'\n" +
+          '  }\n' +
+          '\n' +
+          '  getDetails() {\n' +
+          '    return {\n' +
+          '      from: this.fromAccount.accountNumber,\n' +
+          '      to: this.toAccount.accountNumber,\n' +
+          '      amount: this.amount,\n' +
+          '      timestamp: this.timestamp,\n' +
+          '      status: this.status\n' +
+          '    }\n' +
+          '  }\n' +
+          '\n' +
+          '  isValid() {\n' +
+          '    return this.amount > 0 &&\n' +
+          '           this.fromAccount.getBalance() >= this.amount\n' +
+          '  }\n' +
+          '\n' +
+          '  execute() {\n' +
+          '    if (this.isValid()) {\n' +
+          '      const success = this.fromAccount.send(this.amount, this.toAccount)\n' +
+          "      this.status = success ? 'completed' : 'failed'\n" +
+          '      return success\n' +
+          '    }\n' +
+          "    this.status = 'failed'\n" +
+          '    return false\n' +
+          '  }\n' +
+          '}'
+      ],
+      type: 'text'
+    },
+    {
+      message: '\nPresiona Enter para ver Bank...',
+      type: 'pause'
+    },
+    {
+      lines: [
+        '\n// Implementación de Bank',
+        'class Bank {\n' +
+          '  constructor() {\n' +
+          '    this.accounts = []\n' +
+          '    this.transactions = []\n' +
+          '    this.nextAccountNumber = 1000\n' +
+          '  }\n' +
+          '\n' +
+          '  createAccount(ownerName, initialBalance) {\n' +
+          '    const account = new BankAccount(\n' +
+          '      this.nextAccountNumber++,\n' +
+          '      ownerName,\n' +
+          '      initialBalance\n' +
+          '    )\n' +
+          '    this.accounts.push(account)\n' +
+          '    return account\n' +
+          '  }\n' +
+          '\n' +
+          '  transfer(fromAccount, toAccount, amount) {\n' +
+          '    const transaction = new Transaction(fromAccount, toAccount, amount)\n' +
+          '\n' +
+          '    // El Bank valida ANTES de ejecutar\n' +
+          '    if (this.validateOperation(fromAccount, amount)) {\n' +
+          '      const success = transaction.execute()\n' +
+          '      this.transactions.push(transaction)\n' +
+          '      return transaction\n' +
+          '    }\n' +
+          '\n' +
+          "    transaction.status = 'failed'\n" +
+          '    this.transactions.push(transaction)\n' +
+          '    return transaction\n' +
+          '  }\n' +
+          '\n' +
+          '  validateOperation(account, amount) {\n' +
+          '    return amount > 0 && account.getBalance() >= amount\n' +
+          '  }\n' +
+          '\n' +
+          '  getAllTransactions() {\n' +
+          '    return [...this.transactions]\n' +
+          '  }\n' +
+          '}'
+      ],
+      type: 'text'
+    },
+    {
+      message: '\n' +
+        '✅ Implementación completa. Presiona Enter para probar la interacción...',
+      type: 'pause'
+    },
+    {
+      type: 'clear'
+    },
+    {
+      lines: [
+        '🧪 PASO 4: Probar la Interacción entre Objetos',
+        '=============================================',
+        'Veamos cómo los objetos colaboran usando sus interfaces:',
+        '\n// Crear el sistema bancario',
+        'const bank = new Bank()',
+        "const cuenta1 = bank.createAccount('Ana García', 1000)",
+        "const cuenta2 = bank.createAccount('Carlos López', 500)",
+        '',
+        '// 🔑 ENCAPSULACIÓN: Solo podemos acceder al balance via getBalance()',
+        "console.log('Balance Ana:', cuenta1.getBalance())  // 1000",
+        "console.log('Balance Carlos:', cuenta2.getBalance())  // 500",
+        '',
+        '// 🛡️ VALIDACIÓN: send() verifica internamente antes de ejecutar',
+        'const exitoso = cuenta1.send(300, cuenta2)  // ✅ Tiene fondos',
+        "console.log('Transferencia exitosa:', exitoso)  // true",
+        '',
+        'const fallido = cuenta1.send(1500, cuenta2)  // ❌ Fondos insuficientes',
+        "console.log('Transferencia fallida:', fallido)  // false",
+        '',
+        '// El estado interno se mantiene íntegro',
+        "console.log('Balance final Ana:', cuenta1.getBalance())  // 700",
+        "console.log('Balance final Carlos:', cuenta2.getBalance())  // 800",
+        '\n🎯 Resultado esperado:',
+        'Balance Ana: 1000',
+        'Balance Carlos: 500',
+        'Transferencia exitosa: true',
+        'Transferencia fallida: false',
+        'Balance final Ana: 700',
+        'Balance final Carlos: 800'
+      ],
+      type: 'text'
+    },
+    {
+      message: '\nPresiona Enter para ver los beneficios de este enfoque...',
+      type: 'pause'
+    },
+    {
+      type: 'clear'
+    },
+    {
+      lines: [
+        '🌟 BENEFICIOS DEL DISEÑO INTERFACE-FIRST EN SISTEMAS BANCARIOS',
+        '============================================================',
+        '1. 🔒 Encapsulación: El balance está protegido, solo accesible via getBalance()',
+        '2. 🛡️ Validación: send() incluye lógica de negocio interna',
+        '3. 🎯 Claridad: Cada objeto tiene responsabilidades financieras bien definidas',
+        '4. 🔗 Colaboración: Los objetos saben exactamente cómo solicitar operaciones',
+        '5. 🧪 Testeable: Podemos simular cuentas y transacciones fácilmente',
+        '6. 📚 Mantenible: Las interfaces documentan el contrato bancario',
+        '\n💡 Ejemplo de extensibilidad:',
+        '// Podemos crear diferentes tipos de cuenta sin cambiar Bank',
+        'class SavingsAccount extends BankAccount {',
+        '  getBalance() {',
+        '    return super.getBalance() + this.calculateInterest()',
+        '  }',
+        '}',
+        '',
+        'class CreditAccount extends BankAccount {',
+        '  send(amount, target) {',
+        '    // Permite sobregiro hasta el límite de crédito',
+        '    if (amount > 0 && (this.getBalance() + this.creditLimit) >= amount) {',
+        '      // ... lógica específica',
+        '    }',
+        '  }',
+        '}',
+        '',
+        '// Las cuentas pueden enviarse dinero directamente!',
+        "const savingsAcc = new SavingsAccount(123, 'María', 1000)",
+        "const creditAcc = new CreditAccount(456, 'Juan', 500, 2000)  // límite crédito",
+        'savingsAcc.send(300, creditAcc)  // ¡Funciona con cualquier tipo de cuenta!',
+        '',
+        '// O podemos usar el Bank para registro completo:',
+        'bank.transfer(savingsAcc, creditAcc, 300)  // Crea Transaction automáticamente'
+      ],
+      type: 'text'
+    },
+    {
+      message: '\nPresiona Enter para continuar con la conclusión...',
+      type: 'pause'
+    },
+    {
+      type: 'clear'
+    },
+    {
+      lines: [
+        '🎓 CONCLUSIÓN: Diseño basado en Interfaces (Sistema Bancario)',
+        '=======================================================',
+        '🎯 Hemos demostrado que:',
+        '\n' +
+          '1. El ÉNFASIS debe estar en definir QUÉ solicitudes maneja cada objeto',
+        '2. Las INTERFACES son el CONJUNTO de todas las firmas de operación',
+        '3. Cada FIRMA especifica: nombre, insumos y valor de retorno',
+        '4. La IMPLEMENTACIÓN viene después, siguiendo el contrato',
+        '5. Los objetos COLABORAN a través de estas interfaces bien definidas',
+        '\n📋 Firmas de operación en nuestro ejemplo:',
+        '• BankAccount.getBalance() → number',
+        '• BankAccount.send(amount, targetAccount) → boolean',
+        '• Bank.createAccount(ownerName, initialBalance) → BankAccount',
+        '• Bank.transfer(fromAccount, toAccount, amount) → Transaction',
+        '• Transaction.getDetails() → {from, to, amount, timestamp, status}',
+        '\n🔑 La interfaz de BankAccount es el CONJUNTO completo:',
+        '  {getBalance, getAccountInfo, deposit, send}',
+        '🔑 La interfaz de Bank es el CONJUNTO completo:',
+        '  {createAccount, transfer, getAllTransactions, validateOperation}',
+        '\n💡 Beneficios de este enfoque:',
+        '• ENCAPSULACIÓN: getBalance() protege el acceso al estado interno',
+        '• VALIDACIÓN: send() ejecuta lógica de negocio antes de operar',
+        '• CONTRATO CLARO: Cada firma especifica exactamente qué esperar',
+        '• COLABORACIÓN: Los objetos conocen las firmas de otros objetos',
+        '\n📚 Conexión con lecciones anteriores:',
+        '• Lección 2: Los objetos interactúan a través de solicitudes ✓',
+        '• Lección 3: Las solicitudes son la única forma de ejecutar operaciones ✓',
+        '• Lección 4: Cada operación tiene nombre, insumos y valor de retorno ✓',
+        '• Lección 5: La interfaz es el conjunto de todas las firmas ✓',
+        '• Lección 6: El énfasis está en definir solicitudes e interfaces ✓',
+        '\n🚀 Próximo paso:',
+        'Practica este enfoque en tus propios proyectos:',
+        '1. Define primero QUÉ debe hacer cada objeto',
+        '2. Especifica las interfaces (firmas de operación)',
+        '3. Incluye validaciones internas en tus métodos',
+        '4. Encapsula el estado, expón solo lo necesario',
+        '5. Haz que los objetos colaboren a través de solicitudes',
+        '\n💭 Reflexión final:',
+        'Antes de implementar cualquier objeto, pregúntate:',
+        '• ¿Cuáles son TODAS las firmas de operación que necesito?',
+        '• ¿Qué nombre, insumos y valor de retorno tendrá cada firma?',
+        '• ¿Cómo van a colaborar los objetos usando estas firmas?',
+        '• ¿El CONJUNTO de firmas forma una interfaz coherente?',
+        '\n' +
+          '🏆 ¡Has completado el ejemplo más importante del diseño orientado a objetos!',
+        'Ahora entiendes que el ÉNFASIS debe estar en definir el CONJUNTO',
+        'completo de firmas de operación ANTES de implementar.'
+      ],
+      type: 'text'
+    },
+    {
+      message: '\n✨ ¡Lección 6 completada! Presiona Enter para salir...',
+      type: 'pause'
+    }
+  ]
+}