Todos los artículos

Front-end12 min de lectura

¿Aura fue descontinuado? Qué cambió y cómo migrar a LWC

Aura no tiene fecha de fin, pero el futuro de Salesforce es LWC. Qué se retiró de verdad, cómo conviven los dos y cómo migrar un componente sin romper la página.

También en Português, English, Français

Quien trabaja con Salesforce ya escuchó alguna versión de esta frase: "Aura fue descontinuado, ahora todo es LWC". Es una verdad a medias. Y la parte equivocada es justo la que decide si tienes que reescribir todo mañana o si puedes migrar con calma.

Este post separa lo que de verdad salió de línea de lo que solo dejó de ser el camino recomendado. Después muestra el mismo componente escrito en los dos modelos y una forma de migrar sin romper ninguna página.

Un aviso honesto: todo lo que está aquí viene de la documentación oficial de Salesforce, enlazada al final. Los códigos son ejemplos míos, escritos para mostrar el cambio de un modelo al otro.

TL;DR#

  • Aura no fue descontinuado. A la fecha de este post, no encontré ningún anuncio oficial de fecha de fin para el framework. Los componentes Aura siguen funcionando y pueden estar en la misma página que los componentes LWC.
  • Lo que salió de línea fue el namespace ui, esa familia antigua de componentes Aura (ui:inputText, ui:button y compañía). El soporte terminó el 1 de mayo de 2021.
  • El camino recomendado es LWC. Hacia él apuntan la documentación nueva y las herramientas de migración, y los sitios LWR de Experience Cloud están construidos sobre él.
  • Migrar no es traducir línea por línea. La guía oficial lo dice con todas las letras: es el momento de repensar el componente.
  • Migra de las hojas a la raíz. Un componente Aura puede tener hijos LWC, pero un LWC no puede tener hijos Aura.
  • Componente nuevo, siempre en LWC. Un componente Aura estable que nadie toca puede esperar.

Qué fue descontinuado de verdad#

La confusión nace de una nota de versión de Summer '21 con un título muy directo: los componentes Aura del namespace ui fueron descontinuados. Mucha gente leyó solo la primera mitad de la frase.

El namespace ui era un conjunto de componentes básicos sin el estilo del Lightning Design System (SLDS): campos de texto, botones, menús, spinners. Salesforce terminó el soporte el 1 de mayo de 2021. Siguen funcionando, pero la empresa ya no acepta casos de soporte sobre ellos.

El reemplazo es directo, con los equivalentes del namespace lightning:

Antes (ui, descontinuado)Después (lightning)
ui:inputTextlightning:input (Aura) o lightning-input (LWC)
ui:inputCheckboxlightning:input con type="checkbox"
ui:inputSelectlightning:combobox o lightning-combobox
ui:buttonlightning:button o lightning-button
ui:spinnerlightning:spinner o lightning-spinner
ui:outputDatelightning:formattedDateTime

Si tu org todavía tiene ui: en algún lugar, ese es el primer objetivo. No es todo Aura lo que se quedó sin soporte, es esa familia de componentes.

Entonces, ¿Aura todavía funciona?#

Funciona. La propia guía de migración de Salesforce empieza diciendo que los componentes Aura y LWC pueden existir en la misma aplicación, y enumera tres decisiones válidas después de migrar un primer componente:

  • hacer una migración más grande;
  • usar LWC solo en los componentes nuevos;
  • seguir con Aura por ahora.

O sea: no hay plazo para apagar Aura. Lo que hay es una dirección muy clara. La documentación nueva, los ejemplos y las herramientas de migración apuntan todos a LWC. Y algunos lugares ya no aceptan Aura: las plantillas LWR de Experience Cloud, por ejemplo, se basan en el modelo de LWC y no tienen varios recursos de las plantillas Aura, como los eventos de aplicación.

En la práctica, Aura pasó a ser código legado con soporte: funciona, pero no recibe nada nuevo.

Qué cambia de Aura a LWC#

Aura se creó antes de que los navegadores tuvieran Web Components. Por eso tiene un modelo propio para todo: atributos declarados en XML, eventos propios, un objeto global $A para hablar con el servidor.

LWC usa lo que el navegador ya sabe hacer: clases de JavaScript, módulos con import, Custom Elements y eventos estándar del DOM. Quien ya escribió React, Vue o Web Components lee un LWC sin extrañarse mucho.

La estructura de archivos también cambia. La guía oficial la mapea así:

RecursoAuraLWC
Marcadosample.cmpsample.html
ControllersampleController.jssample.js
HelpersampleHelper.jssample.js
RenderersampleRenderer.jssample.js
CSSsample.csssample.css
Design (Lightning App Builder)sample.designsample.js-meta.xml

Controller, helper y renderer se vuelven un solo archivo. Es una clase, y las funciones del helper pasan a ser sus métodos.

El mismo componente en los dos modelos#

Un ejemplo pequeño, pero con las piezas que aparecen en casi todo componente real: recibe el id del registro de la página, busca datos en Apex al abrirse y muestra una lista o un texto de "vacío".

El Apex (casi no cambia)#

ContactController.cls
public with sharing class ContactController {
    @AuraEnabled(cacheable=true)
    public static List<Contact> getContacts(Id accountId) {
        return [
            SELECT Id, Name
            FROM Contact
            WHERE AccountId = :accountId
            WITH USER_MODE
            LIMIT 50
        ];
    }
}

La guía dice que el Apex es el mismo en los dos modelos. La única diferencia aparece si quieres usar @wire en LWC: el método necesita cacheable=true. Un método que guarda datos no puede ser cacheable, y entonces se llama de forma imperativa (lo muestro más abajo).

En Aura#

contactList.cmp
<aura:component controller="ContactController"
                implements="flexipage:availableForRecordHome,force:hasRecordId">
    <aura:attribute name="contacts" type="Contact[]" />
    <aura:handler name="init" value="{!this}" action="{!c.doInit}" />
 
    <lightning:card title="Contacts">
        <aura:if isTrue="{!not(empty(v.contacts))}">
            <ul class="slds-p-horizontal_medium">
                <aura:iteration items="{!v.contacts}" var="contact">
                    <li>{!contact.Name}</li>
                </aura:iteration>
            </ul>
            <aura:set attribute="else">
                <p class="slds-p-horizontal_medium">No contacts yet.</p>
            </aura:set>
        </aura:if>
    </lightning:card>
</aura:component>
contactListController.js
({
    doInit: function (component, event, helper) {
        helper.loadContacts(component);
    }
})
contactListHelper.js
({
    loadContacts: function (component) {
        var action = component.get('c.getContacts');
        action.setParams({ accountId: component.get('v.recordId') });
        action.setCallback(this, function (response) {
            if (response.getState() === 'SUCCESS') {
                component.set('v.contacts', response.getReturnValue());
            }
        });
        $A.enqueueAction(action);
    }
})

Tres archivos, un evento init y la llamada al servidor armada a mano con setParams, setCallback y $A.enqueueAction.

En LWC#

contactList.html
<template>
    <lightning-card title="Contacts">
        <template lwc:if={hasContacts}>
            <ul class="slds-p-horizontal_medium">
                <template for:each={contacts.data} for:item="contact">
                    <li key={contact.Id}>{contact.Name}</li>
                </template>
            </ul>
        </template>
        <template lwc:else>
            <p class="slds-p-horizontal_medium">No contacts yet.</p>
        </template>
    </lightning-card>
</template>
contactList.js
import { LightningElement, api, wire } from 'lwc';
import getContacts from '@salesforce/apex/ContactController.getContacts';
 
export default class ContactList extends LightningElement {
    @api recordId;
 
    @wire(getContacts, { accountId: '$recordId' })
    contacts;
 
    get hasContacts() {
        return Array.isArray(this.contacts.data) && this.contacts.data.length > 0;
    }
}
contactList.js-meta.xml
<?xml version="1.0" encoding="UTF-8"?>
<LightningComponentBundle xmlns="http://soap.sforce.com/2006/04/metadata">
    <apiVersion>62.0</apiVersion>
    <isExposed>true</isExposed>
    <targets>
        <target>lightning__RecordPage</target>
    </targets>
</LightningComponentBundle>

Qué cambió, punto por punto:

  • aura:attribute pasó a ser una propiedad de la clase. @api hace público recordId, y la página lo completa sola porque el componente está en una página de registro.
  • El init desapareció. @wire llama al Apex cuando el componente entra en pantalla y lo vuelve a llamar cuando cambia recordId. El $ delante de '$recordId' es lo que activa esa reactividad.
  • La expresión salió del HTML. Una plantilla de LWC no acepta not(empty(...)). La lógica va a un getter (hasContacts), y el HTML solo lee el resultado.
  • aura:iteration pasó a ser for:each, con key obligatorio en cada elemento.
  • aura:if pasó a ser lwc:if / lwc:else. Los antiguos if:true e if:false todavía existen, pero la documentación dice que ya no se recomiendan. En código nuevo, usa lwc:if, lwc:elseif y lwc:else.

Un detalle que atrapa a quien migra: @wire entrega un objeto con data y error. Mientras carga, los dos están vacíos. En un componente real, conviene tratar el error y mostrar un estado de carga.

¿Y cuando la llamada no puede ser @wire?#

Para guardar datos, o para llamar al Apex solo cuando el usuario hace clic, importa el método y llámalo como una función que devuelve una Promise. Aquí, suponiendo un método saveContact en el mismo controller, sin cacheable:

contactForm.js
import { LightningElement, api } from 'lwc';
import { ShowToastEvent } from 'lightning/platformShowToastEvent';
import saveContact from '@salesforce/apex/ContactController.saveContact';
 
export default class ContactForm extends LightningElement {
    @api recordId;
    lastName = '';
 
    handleChange(event) {
        this.lastName = event.target.value;
    }
 
    async handleSave() {
        try {
            await saveContact({ accountId: this.recordId, lastName: this.lastName });
            this.dispatchEvent(new ShowToastEvent({ title: 'Contact saved', variant: 'success' }));
        } catch (error) {
            this.dispatchEvent(new ShowToastEvent({ title: 'Could not save', message: error.body.message, variant: 'error' }));
        }
    }
}

El force:showToast de Aura pasó a ser ShowToastEvent, importado de lightning/platformShowToastEvent. Es el patrón de casi todo evento force: de Aura: se convierte en un módulo que importas.

Eventos: de fire() a dispatchEvent#

En Aura, el hijo registra el evento en el marcado (aura:registerEvent), arma el evento y lo dispara con fire():

contactItemController.js (Aura)
({
    handleClick: function (component) {
        var selectEvent = component.getEvent('select');
        selectEvent.setParams({ contactId: component.get('v.contactId') });
        selectEvent.fire();
    }
})

En LWC no hay registro. El hijo crea un CustomEvent, que es del propio navegador, y lo dispara con dispatchEvent:

contactItem.js
handleClick() {
    this.dispatchEvent(new CustomEvent('select', { detail: { contactId: this.contactId } }));
}

El padre escucha con on + el nombre del evento y lee el contenido en event.detail:

contactList.html
<c-contact-item contact-id={contact.Id} onselect={handleSelect}></c-contact-item>
contactList.js
handleSelect(event) {
    const { contactId } = event.detail;
}

Dos convenciones evitan dolores de cabeza: el nombre del evento va en minúsculas y sin el prefijo on (dispara select, escucha onselect), y una propiedad en camelCase en JavaScript pasa a kebab-case en el HTML (contactId pasa a ser contact-id).

Para componentes que no son padre e hijo, el sustituto de los eventos de aplicación de Aura es Lightning Message Service (lightning/messageService), que funciona entre componentes de la misma página y de páginas distintas.

Tabla de equivalencias#

Los cambios que más aparecen, todos sacados de la guía oficial de migración:

AuraLWC
<aura:attribute>propiedad de la clase (@api si es pública)
<aura:iteration>for:each con key
<aura:if>lwc:if, lwc:elseif, lwc:else
init (aura:valueInit)connectedCallback()
aura:valueRenderrenderedCallback()
aura:valueDestroydisconnectedCallback()
aura:valueChangegetter y setter en la propiedad
component.getEvent() + fire()new CustomEvent() + dispatchEvent()
evento de aplicaciónLightning Message Service
$A.enqueueAction()@wire o import del método Apex
force:showToastShowToastEvent
force:navigateToSObject, force:navigateToURL y similaresservicio de navegación (lightning/navigation)
force:refreshViewRefreshView API
ltng:requirelightning/platformResourceLoader

Cómo conviven los dos en la misma página#

La regla más importante de toda la migración es esta, directo de la documentación:

  • un componente Aura puede contener un LWC;
  • un LWC no puede contener un componente Aura.
El LWC puede vivir dentro de Aura. El camino inverso no existe

Dentro de un Aura, el LWC entra con el namespace c: y el nombre en camelCase. Sus eventos se escuchan como cualquier otro:

accountPanel.cmp
<aura:component implements="flexipage:availableForRecordHome,force:hasRecordId">
    <c:contactList recordId="{!v.recordId}" onselect="{!c.handleSelect}" />
</aura:component>
accountPanelController.js
({
    handleSelect: function (component, event) {
        var contactId = event.getParam('contactId');
    }
})

Esta regla define el orden de la migración: cambias los componentes de abajo hacia arriba. Primero las hojas, que no tienen hijos. Los padres en Aura siguen funcionando con hijos LWC adentro. Cuando todos los hijos de un padre ya son LWC, le llega el turno al padre.

En cada etapa, cada componente Aura solo tiene hijos que sabe renderizar

Una trampa: si el componente Aura recibe otros componentes Aura por facet (un atributo de tipo Aura.Component[], como un "slot"), esos también tienen que migrarse antes, porque el LWC no podrá renderizarlos.

Un plan de migración que no rompe nada#

La guía oficial sugiere un orden, y funciona bien como hoja de ruta:

  1. Haz un inventario. Lista los componentes Aura del org, quién usa a quién y cuántas pruebas tiene cada uno.
  2. Empieza por un componente solo de interfaz, sin dependencias. Usa los componentes base (lightning-*) siempre que exista un equivalente.
  3. Después los utilitarios sin interfaz, que en Aura usan aura:method. En LWC pasan a ser un módulo de JavaScript común, con funciones exportadas.
  4. Después los componentes que disparan eventos.
  5. Después los que leen registros o llaman APIs de Salesforce, cambiándolos por @wire y los módulos equivalentes.
  6. Por último los padres, cuando todos sus hijos ya sean LWC.

Y dos consejos que valen más que cualquier tabla:

  • Migra árboles, no piezas sueltas. La guía dice que la ganancia de rendimiento y de productividad aparece cuando migras un árbol entero de componentes, no un componente aislado.
  • Escribe pruebas en Jest antes de borrar el Aura. LWC tiene pruebas unitarias con Jest. Son tu garantía de que el componente nuevo hace lo mismo que el antiguo.

¿Y la IA ayuda?#

Salesforce ahora menciona asistentes de IA en la propia guía de migración. El servidor MCP de Salesforce DX tiene un conjunto de herramientas llamado aura-experts, en beta, que analiza un componente Aura, escribe una especificación y genera el LWC a partir de ella. La página de esas herramientas avisa que fueron reemplazadas por una skill de migración (experience-aura-lwc-migrate), así que revisa la versión actual antes de configurarla.

Sirve para acelerar la parte pesada. Pero la propia documentación recuerda que la salida la genera una IA, puede venir con errores y revisarla es tu responsabilidad. La IA traduce sintaxis muy bien. Lo que no sabe es qué comportamiento antiguo era un bug y cuál era una regla de negocio.

¿Vale la pena migrar ahora?#

Mi recomendación, mirando lo que Salesforce dice y lo que no dice:

  • Componente nuevo: siempre LWC. No hay motivo para empezar nada en Aura hoy.
  • Tienes ui: en el org: migra ya. Está sin soporte desde 2021.
  • Vas a crear o mover un sitio a la plantilla LWR: necesitas LWC.
  • Vas a tocar mucho un componente Aura: aprovecha y migra. El costo de entender el componente ya lo estás pagando.
  • Componente Aura estable que nadie toca: puede esperar. Reescribir código que funciona solo por reescribirlo es riesgo sin retorno. Ponlo en el inventario y migra cuando lo toques.

Checklist#

  • Ningún componente ui: sobrando en el org.
  • Los componentes nuevos nacen en LWC.
  • Inventario de los componentes Aura con dependencias y cobertura de pruebas.
  • Migración de las hojas a la raíz, sin LWC intentando contener Aura.
  • Facets (Aura.Component[]) migrados junto con el componente que los recibe.
  • if:true/if:false cambiados por lwc:if/lwc:elseif/lwc:else.
  • Métodos Apex usados con @wire marcados como cacheable=true.
  • Eventos con nombre en minúsculas, sin on, contenido en detail.
  • Eventos de aplicación cambiados por Lightning Message Service.
  • Pruebas en Jest antes de borrar el componente Aura.
  • Código generado por IA revisado línea por línea.

Referencias#

Escrito por

Ingeniera de software y diseñadora. Escribo sobre lo que encuentro construyendo apps, APIs y productos.

Comentarios

Para comentar, entra con tu cuenta de GitHub.