A Salesforce acabou de tornar oficial o Multi-Framework. Agora você pode rodar apps React nativamente na plataforma — com autenticação, segurança e governança já incluídos.
Se você é desenvolvedor Salesforce e já tentou integrar React com a plataforma, sabe como era doloroso. Autenticação manual, tokens expirando, CORS configurado errado, segurança costurada com fita. Tudo isso mudou na última segunda-feira, quando a Salesforce tornou geralmente disponível o Multi-Framework — e o React agora roda nativamente dentro do Salesforce.
Não é mais beta. Não é mais experimental. É produção.
O Que É o Multi-Framework Exatamente?
O Multi-Framework é um runtime agnóstico de framework no Headless 360 Platform. Na prática, significa que você pode construir aplicações React completas que rodam dentro do Salesforce como se fossem componentes nativos. Sem iframes. Sem workarounds. Sem gambiarra.
A mágica acontece porque o Multi-Framework conecta seu app React diretamente às APIs do Salesforce. Você usa GraphQL para consultar registros, invoca métodos Apex, lê o contexto do usuário pelas APIs de UI — e tudo isso sem precisar gerenciar autenticação ou tokens. A segurança e a governança do Salesforce já estão embutidas.
Para quem vem do mundo React, pense nisso como ter o melhor dos dois mundos: o ecossistema React com toda a sua flexibilidade, e a plataforma Salesforce com toda a sua robustez empresarial.
O Que Mudou da Beta para a GA?
A versão beta foi lançada em abril deste ano durante o TrailblazerDX 2026. Desde então, a Salesforce trabalhou em várias melhorias importantes que tornaram o GA uma versão mais madura e confiável.
Suporte a Orgs de Produção
A mudança mais significativa é o suporte completo a orgs de produção, sandbox, Developer Edition e scratch orgs. Na beta, você precisava habilitar manualmente. Agora, com o Summer ’26, o Multi-Framework já vem ativo em todas as orgs — sem necessidade de configuração adicional.
O Novo Domínio salesforce.app
Cada aplicação Multi-Framework agora roda no domínio dedicado salesforce.app. O padrão de URL segue esta estrutura:
https://<org>--<namespace>.<instance>.my.salesforce.app/app/c__<bundleName>Por exemplo:
https://acme-corp-dev-ed--c.scratch.my.salesforce.app/app/c__myReactAppIsso não é apenas cosmético. Cada app roda em sua própria origem, o que significa que o Same Origin Policy do navegador garante isolamento nativo. Uma aplicação não consegue ler cookies ou storage de outra. Segurança de verdade, sem sandboxing proprietário.
Data SDK com Breaking Changes
O pacote mudou de @salesforce/sdk-data para @salesforce/platform-sdk. Se você construiu algo na beta, precisa atualizar seus imports e a forma como faz queries.
Na beta, tanto queries quanto mutations usavam o mesmo método .graphql():
import { createDataSDK, gql } from '@salesforce/sdk-data';
const sdk = await createDataSDK();
const result = await sdk.graphql?.<QueryResponse>({ query: MY_QUERY });
const mutationResult = await sdk.graphql?.<MutationResponse>({
query: MY_MUTATION,
variables: { input },
});Na GA, reads e writes usam métodos separados:
import { createDataSDK, gql } from '@salesforce/platform-sdk';
const sdk = await createDataSDK();
// Reads usam .query()
const result = await sdk.graphql?.query<QueryResponse>({ query: MY_QUERY });
// Writes usam .mutate()
const mutationResult = await sdk.graphql?.mutate<MutationResponse>({
mutation: MY_MUTATION,
variables: { input },
});Outra mudança importante: result.data agora pode ser undefined. Na beta, você podia assumir que sempre existia. Na GA, é obrigatório usar optional chaining:
// Antes (beta) — assumia que data existia
const edges = result?.data.uiapi?.query?.Account?.edges;
// Depois (GA) — optional chaining obrigatório
const edges = result?.data?.uiapi?.query?.Account?.edges;Mudança no Target de Metadata
O target AppLauncher foi depreciado. Agora você precisa usar CustomApplication no seu .uibundle-meta.xml:
<UIBundle xmlns="http://soap.sforce.com/2006/04/metadata">
<masterLabel>Minha App</masterLabel>
<description>Uma aplicação React no Salesforce.</description>
<isActive>true</isActive>
<version>1</version>
<target>CustomApplication</target>
</UIBundle>Além disso, você precisa criar um metadata de Custom Application que referencia o bundle:
<CustomApplication xmlns="http://soap.sforce.com/2006/04/metadata">
<label>Minha App React</label>
<navType>Standard</navType>
<uiBundle>c__minhaAppReact</uiBundle>
<uiType>Lightning</uiType>
<formFactors>Large</formFactors>
</CustomApplication>E um Permission Set para conceder visibilidade:
<PermissionSet xmlns="http://soap.sforce.com/2006/04/metadata">
<applicationVisibilities>
<application>minhaAppReact</application>
<visible>true</visible>
</applicationVisibilities>
<label>Minha App React Access</label>
<hasActivationRequired>false</hasActivationRequired>
</PermissionSet>Cinco Passos para Migrar da Beta para a GA
Se você já tem algo construído na beta, aqui está o checklist completo de migração:
1. Atualize o import do pacote
De @salesforce/sdk-data para @salesforce/platform-sdk.
2. Separe queries de mutations
Substitua chamadas genéricas de .graphql() por .query() para leituras e .mutate() para escritas.
3. Adicione optional chaining
result.data agora pode ser undefined. Use result?.data?.uiapi em vez de result.data.uiapi.
4. Atualize o target de metadata
Troque <target>AppLauncher</target> por <target>CustomApplication</target> no .uibundle-meta.xml e adicione os metadados de Custom Application e Permission Set.
5. Remova configurações depreciadas
O UiBundleSettings de scratch config não é mais necessário. Pode deletar.
Como Funciona na Prática?
Vamos ver um exemplo real de como consultar dados do Salesforce dentro de um componente React:
import { createDataSDK, gql } from '@salesforce/platform-sdk';
import { useState, useEffect } from 'react';
const ACCOUNT_QUERY = gql`
query GetAccounts {
uiapi {
query {
Account(first: 10) {
edges {
node {
Id
Name { value }
Industry { value }
}
}
}
}
}
}
`;
function AccountList() {
const [accounts, setAccounts] = useState([]);
const [loading, setLoading] = useState(true);
useEffect(() => {
async function fetchAccounts() {
const sdk = await createDataSDK();
const result = await sdk.graphql?.query({ query: ACCOUNT_QUERY });
const edges = result?.data?.uiapi?.query?.Account?.edges ?? [];
setAccounts(edges.map(edge => ({
id: edge.node.Id,
name: edge.node.Name.value,
industry: edge.node.Industry.value,
})));
setLoading(false);
}
fetchAccounts();
}, []);
if (loading) return <div>Carregando...</div>;
return (
<ul>
{accounts.map(account => (
<li key={account.id}>
{account.name} — {account.industry}
</li>
))}
</ul>
);
}
export default AccountList;Note como não há configuração de autenticação. Não há token para gerenciar. Não há CORS para configurar. O SDK cuida de tudo isso automaticamente porque o app já roda dentro do contexto seguro do Salesforce.
O Que Vem Por Aí?
A Salesforce já revelou o roadmap público do Multi-Framework, e tem coisa interessante chegando:
Microfrontends — A capacidade de incorporar componentes React hospedados externamente no Lightning, ao lado de LWCs nativos, com comunicação via eventos entre eles.
Suporte a Angular — O framework Angular será o próximo a ter suporte nativo, expandindo as opções para equipes que não usam React.
Localização — Suporte completo a Translation Workbench para adaptar componentes Multi-Framework a diferentes idiomas, localidades e fusos horários.
Managed packages — A capacidade de construir, testar, distribuir e deployar aplicações Multi-Framework como managed packages.
Impacto para Desenvolvedores e Empresas
Essa mudança tem implicações profundas para o ecossistema Salesforce.
Para desenvolvedores React, a barreira de entrada no Salesforce despenca. Você não precisa mais aprender Aura ou LWC para construir interfaces sofisticadas na plataforma. Seu time já tem as habilidades necessárias.
Para arquitetos, o Multi-Framework resolve o dilema clássico de “construir na plataforma vs. construir fora”. Agora você pode ter os dois: a flexibilidade do React com a governança do Salesforce.
Para empresas, o custo de desenvolvimento cai significativamente. Menos integrações customizadas, menos pontos de falha, menos manutenção. E o melhor: tudo roda dentro do perímetro de segurança do Salesforce, o que simplifica auditorias e compliance.
Conclusão
O Multi-Framework saindo do beta para GA não é apenas mais uma feature do Summer ’26. É uma mudança de paradigma na forma como construímos aplicações no Salesforce. O React agora é um cidadão de primeira classe na plataforma, com toda a segurança e governança que isso implica.
Se você ainda não experimentou, agora é o momento. A documentação oficial está disponível no Developer Guide do Multi-Framework, e o repositório multiframework-recipes tem mais de 20 exemplos de código para começar.
Para times que já construíram na beta, o checklist de migração é direto. Cinco passos, sem surpresas. E para quem está começando do zero, o caminho nunca foi tão curto: crie um bundle, configure o target, e você tem um app React rodando nativamente no Salesforce.
A pergunta não é mais “devo usar React no Salesforce?”. É “quando vou começar?”.