|
| Home → WINDEV 25 → Windev com Supabase : REST API, Authentification et Realtime |
| Windev com Supabase : REST API, Authentification et Realtime |
| Started by Boller, May, 21 2025 11:17 PM - 1 reply |
| |
| | | |
|
| |
Registered member
4,520 messages |
|
| Posted on May, 21 2025 - 11:17 PM |
Boa tarde Pessoal,
WinDev e Supabase: API REST, Autenticação e Realtime
No contexto da modernização das arquiteturas de software, cada vez mais equipes de desenvolvimento buscam combinar a robustez de ferramentas tradicionais como o WinDev com soluções modernas em nuvem como o Supabase. Essa combinação pode parecer atípica à primeira vista, mas abre caminho para aplicações híbridas mais ágeis, seguras e escaláveis.
Neste artigo, exploramos as possibilidades oferecidas pelo Supabase, especialmente por meio de suas APIs REST, seu sistema de autenticação integrado, e destacamos as vantagens que isso pode oferecer em comparação com um PostgreSQL clássico usado isoladamente, particularmente em um ambiente WinDev.
⸻
O que é o Supabase?
O Supabase é uma plataforma Backend-as-a-Service (BaaS) de código aberto baseada no PostgreSQL. Ele oferece: 
• APIs REST automáticas geradas a partir da estrutura do banco de dados;
• Um sistema completo de autenticação (email, magic link, OAuth, etc.);
• Gerenciamento de funções e políticas de segurança (RLS);
• Armazenamento de arquivos e um console de administração amigável;
• Um mecanismo Realtime integrado para receber instantaneamente alterações nos dados. 
O Supabase se posiciona como uma alternativa de código aberto ao Firebase, com o poder e a confiabilidade de um PostgreSQL enriquecido com funcionalidades modernas. 
Com seu módulo Realtime, o Supabase permite escutar em tempo real as modificações feitas nas tabelas (inserções, atualizações, exclusões) por meio de um canal WebSocket seguro. Isso abre caminho para aplicações reativas, sem a necessidade de interrogar constantemente o banco de dados.
⸻
Utilizando as APIs REST do Supabase no WinDev
Um dos grandes atrativos do Supabase reside em suas APIs REST expostas automaticamente. Para um desenvolvedor WinDev, isso significa que é possível interagir com o banco de dados sem nenhum conector nativo do PostgreSQL, simplesmente por meio de chamadas HTTP.
As funções HTTP integradas do WinDev (HTTPRequête, HTTPLitFichier, etc.) permitem facilmente:
• Recuperar dados de uma tabela;
• Inserir ou atualizar registros;
• Gerenciar erros e status HTTP. 
Cada tabela do Supabase torna-se assim um recurso REST, seguro, versionado e imediatamente acessível.
Essa separação entre a aplicação cliente WinDev e o banco de dados permite:
• Acesso remoto sem túnel VPN ou porta aberta;
• Separação de responsabilidades (backend vs cliente);
• Melhor escalabilidade.
⸻
Autenticação nativa do Supabase: simplifique a segurança
Graças às APIs do Supabase, é possível integrar:
• Autenticação por email/senha;
• Links mágicos para conexões sem senha;
• Provedores OAuth como Google, GitHub, Microsoft. 
A integração baseia-se em chamadas HTTP POST para os endpoints /auth/v1/token ou /auth/v1/signup. 
Uma vez conectado, o usuário recebe um JWT (token de autenticação) a ser incluído nas requisições futuras. Esse token permite:
• Proteger o acesso aos recursos;
• Definir dinamicamente os direitos por meio das políticas RLS no Supabase;
• Garantir uma autenticação centralizada, sem reinventar a roda no WinDev.
Esse mecanismo torna obsoleta a gestão manual de sessões ou senhas no WinDev, ao mesmo tempo em que oferece uma segurança moderna compatível com o RGPD.
⸻
Supabase vs PostgreSQL clássico
O Supabase utiliza o PostgreSQL, mas vai muito além ao simplificar drasticamente a exploração e a segurança.
Aqui está uma comparação clara:
Critério PostgreSQL Clássico Supabase
Implantação Auto-hospedado, manutenção própria SaaS ou auto-hospedado, pronto para uso
API REST Desenvolvida manualmente Geradas automaticamente
Autenticação Implementada separadamente Nativa, OAuth, Magic Link, RLS
Segurança dos dados Requer desenvolvimento Políticas RLS integradas
Integração no WinDev Via conectores PostgreSQL Via HTTP REST (universal e nativo)
Escalabilidade Gerenciada manualmente Automatizada (conforme oferta do Supabase)
Manutenção Requer expertise em DBA Simplificada via console do Supabase
Assim, em vez de utilizar um servidor PostgreSQL puro que exige esforços de administração, segurança e desenvolvimento backend, o Supabase oferece uma camada adicional pronta para uso que facilita drasticamente a implementação de projetos conectados, especialmente em contextos WinDev onde as funções REST são mais flexíveis de implantar do que os conectores nativos SQL.
⸻
Escalabilidade: uma alavanca estratégica facilitada pelo Supabase
A escalabilidade é frequentemente um ponto crítico na escolha de uma arquitetura. O Supabase, com sua infraestrutura baseada em nuvem e recursos como APIs REST automáticas, autenticação integrada e políticas de segurança, permite que as aplicações cresçam de forma mais ágil e segura, adaptando-se às necessidades crescentes sem a complexidade de gerenciar servidores e infraestrutura manualmente.
⸻
Para mais detalhes, você pode acessar o artigo original no blog da IsiNeva: Windev et Supabase : REST API, Authentification et Realtime. 
https://www.isineva.com/windev-avec-supabase-api-authentification-avantages/
⸻
Aqui está uma classe WLanguage (clsSupabaseClient) para integração com Supabase via API REST, cobrindo autenticação e operações básicas (GET, POST, PATCH e DELETE). O foco é usar as funções HTTPRequest, HTTPGetResult e manter segurança via token JWT.
⸻
WLanguage Class: clsSupabaseClient
// #########################################################
// Classe: clsSupabaseClient
// Descrição: Cliente REST para Supabase com autenticação JWT
// Autor: Adriano Boller - WX Soluções
// #########################################################
// Classe
CLASS clsSupabaseClient
// Membros privados
PRIVATE
cBaseURL is string
cApiKey is string
cJWT is string
// Construtor
CONSTRUCTOR(sURL is string, sAPIKey is string)
cBaseURL = sURL
cApiKey = sAPIKey
cJWT = ""
END
// Método: Autentica usuário via e-mail e senha
PROCEDURE Login(sEmail is string, sSenha is string)
sJSON is string = [
{
"email":"] + sEmail + [",
"password":"] + sSenha + ["
}
]
HTTPRequest(cBaseURL + "/auth/v1/token?grant_type=password", httpPost, sJSON, "application/json", cApiKeyHeader())
IF HTTPStatus() = 200 THEN
resposta is JSON = JSONToVariant(HTTPGetResult(httpResult))
cJWT = resposta.token
RESULT True
ELSE
Info("Erro na autenticação: " + HTTPGetResult(httpResult))
RESULT False
END
END
// Método: GET - busca dados de uma tabela
PROCEDURE Get(sTabela is string)
HTTPRequest(cBaseURL + "/rest/v1/" + sTabela, httpGet, "", "", jwtHeaders())
IF HTTPStatus() = 200 THEN
RESULT HTTPGetResult(httpResult)
ELSE
Info("Erro ao buscar dados: " + HTTPGetResult(httpResult))
RESULT ""
END
END
// Método: POST - insere dados
PROCEDURE Post(sTabela is string, sJSON is string)
HTTPRequest(cBaseURL + "/rest/v1/" + sTabela, httpPost, sJSON, "application/json", jwtHeaders())
IF HTTPStatus() = 201 OR HTTPStatus() = 200 THEN
RESULT HTTPGetResult(httpResult)
ELSE
Info("Erro ao inserir dados: " + HTTPGetResult(httpResult))
RESULT ""
END
END
// Método: PATCH - atualiza dados com filtro
PROCEDURE Patch(sTabela is string, sFiltro is string, sJSON is string)
sURL is string = cBaseURL + "/rest/v1/" + sTabela + "?" + URLEncode(sFiltro)
HTTPRequest(sURL, httpPatch, sJSON, "application/json", jwtHeaders())
IF HTTPStatus() = 204 THEN
RESULT "Atualização feita com sucesso"
ELSE
Info("Erro ao atualizar: " + HTTPGetResult(httpResult))
RESULT ""
END
END
// Método: DELETE - remove dados com filtro
PROCEDURE Delete(sTabela is string, sFiltro is string)
sURL is string = cBaseURL + "/rest/v1/" + sTabela + "?" + URLEncode(sFiltro)
HTTPRequest(sURL, httpDelete, "", "", jwtHeaders())
IF HTTPStatus() = 204 THEN
RESULT "Remoção feita com sucesso"
ELSE
Info("Erro ao remover: " + HTTPGetResult(httpResult))
RESULT ""
END
END
// Cabeçalho com JWT e API Key
PROCEDURE jwtHeaders()
arrHeaders is array of strings
Add(arrHeaders, "apikey: " + cApiKey)
Add(arrHeaders, "Authorization: Bearer " + cJWT)
RESULT arrHeaders
END
// Cabeçalho somente com API Key
PROCEDURE cApiKeyHeader()
arrHeaders is array of strings
Add(arrHeaders, "apikey: " + cApiKey)
RESULT arrHeaders
END
END
⸻
Exemplo de uso:
supabase is clsSupabaseClient("https://xyzcompany.supabase.co", "API_KEY")
IF supabase.Login("usuario@email.com", "senha123") THEN
dadosJSON is string = supabase.Get("clientes")
Info(dadosJSON)
END
⸻
Exemplo de uso
Perfeito! Vamos criar um exemplo prático e realista de uso da classe clsSupabaseClient, com um caso de CRUD completo sobre a tabela clientes, simulando um app de cadastro de clientes com Supabase + WinDev, via REST API.
⸻
Cenário: App WinDev de Cadastro de Clientes
Você está criando um aplicativo WinDev para gerenciar clientes de uma empresa. O backend está hospedado no Supabase, com uma tabela chamada clientes que possui os seguintes campos:
Campo Tipo
id UUID (PK)
nome text
email text
telefone text
criado_em timestamp
⸻
1. Inicialização do Cliente Supabase
// Inicializar a classe com a URL do Supabase e a chave pública do projeto
supabase is clsSupabaseClient("https://xyzcompany.supabase.co", "eyJhbGciOi...")
⸻
2. Login do usuário (para obter o JWT)
IF NOT supabase.Login("admin@empresa.com", "senhaSecreta") THEN
Error("Não foi possível autenticar.")
RETURN
END
⸻
3. Inserir um novo cliente (POST)
novoClienteJSON is string = [
{
"id":"] + GUIDGenerate() + [",
"nome":"Maria Silva",
"email":"maria@email.com",
"telefone":"(41) 99999-1234",
"criado_em":"2025-05-21T10:00:00Z"
}
]
resultadoPost is string = supabase.Post("clientes", novoClienteJSON)
Info("Cliente inserido com sucesso: " + resultadoPost)
⸻
4. Listar todos os clientes (GET)
clientesJSON is string = supabase.Get("clientes")
Info("Clientes cadastrados: " + clientesJSON)
⸻
5. Atualizar telefone do cliente (PATCH)
// Filtro: id igual ao UUID do cliente (exemplo fixo)
filtro is string = "id=eq.74f6c9d5-8f5a-4f67-9f3a-a45a8235f900"
atualizacaoJSON is string = [
{
"telefone":"(41) 98888-7777"
}
]
resultadoPatch is string = supabase.Patch("clientes", filtro, atualizacaoJSON)
Info(resultadoPatch)
⸻
6. Remover um cliente (DELETE)
filtroExcluir is string = "email=eq.maria@email.com"
resultadoDelete is string = supabase.Delete("clientes", filtroExcluir)
Info(resultadoDelete)
⸻
Resumo Visual do Fluxo:
1. Autentica via e-mail/senha e recebe token JWT.
2. Usa esse token para fazer requisições REST (inserção, leitura, atualização e exclusão).
3. Tudo via comandos HTTPRequest, sem conexão direta SQL ou driver.
⸻
Vantagens do Uso em Produção
• Alta segurança: autenticação via JWT + política RLS no Supabase.
• Sem conexão direta ao banco: ideal para dispositivos móveis ou clientes leves.
• Alta escalabilidade: backend preparado para milhares de conexões simultâneas.
• Controle completo no WinDev sem depender de conectores SQL nativos.
⸻
Bons estudos
--
Adriano José Boller
______________________________________________
Consultor e Representante Oficial da
PcSoft no Brasil
+55 (41) 99949 1800
adrianoboller@gmail.com
skype: adrianoboller
http://wxinformatica.com.br/ |
| |
| |
| | | |
|
| | |
| |
Registered member
4,520 messages |
|
| Posted on May, 21 2025 - 11:26 PM |
A finalidade da classe clsSupabaseClient é integrar de forma segura, moderna e escalável um aplicativo WinDev (desktop, web ou mobile) com o Supabase, utilizando REST APIs e autenticação JWT — sem precisar de drivers SQL nativos ou conexões diretas com o banco de dados.
⸻
Objetivos Principais
1. Substituir conexão direta com banco por APIs
Evita abrir portas de banco de dados na internet e elimina o uso de drivers PostgreSQL, que podem ser limitados em dispositivos móveis ou ambientes restritos.
2. Facilitar autenticação segura
A classe usa o sistema de login integrado do Supabase (com e-mail/senha, OAuth ou magic link), retornando um token JWT que garante:
• Sessões seguras.
• Acesso controlado por usuário.
• Rastreabilidade de ações.
3. Permitir operações CRUD por HTTP
Com ela você pode:
• Inserir dados (Post)
• Buscar dados (Get)
• Atualizar registros (Patch)
• Remover registros (Delete)
Tudo via REST, usando HTTPRequest, com performance e flexibilidade.
⸻
Quando usar?
• Aplicativos mobile em WinDev Mobile com banco remoto.
• Interfaces WebDev conectadas à nuvem sem drivers pesados.
• Soluções WinDev desktop em ambientes distribuídos (vendedores externos, ERP leve, dashboards, etc.).
• Projetos com múltiplos clientes simultâneos, onde o banco precisa ser escalável e seguro.
• Soluções com controle de acesso por usuário via Supabase Auth.
⸻
Exemplos de Casos Reais
Caso Benefício
App de vendas externo com WinDev Mobile Conecta-se via HTTPS e envia pedidos ao banco em tempo real
Portal de clientes em WebDev Usuários autenticam-se com Supabase e veem apenas seus próprios dados
ERP com dashboards Dados são consumidos com segurança sem conexão direta com o banco
Aplicativo que precisa sincronizar dados offline Dados podem ser enviados via REST assim que a conexão voltar
⸻
Resumo Final
A classe clsSupabaseClient transforma WinDev em um cliente REST moderno, compatível com arquiteturas de microserviços e bancos PostgreSQL gerenciados, abrindo caminho para projetos multiplataforma, escaláveis e com segurança de nível enterprise — sem complicar a vida do desenvolvedor.
⸻
Bons estudos
--
Adriano José Boller
______________________________________________
Consultor e Representante Oficial da
PcSoft no Brasil
+55 (41) 99949 1800
adrianoboller@gmail.com
skype: adrianoboller
http://wxinformatica.com.br/ |
| |
| |
| | | |
|
| | | | |
| | |
|