Forem: João Neto

Simplificando verificações de flags binárias

João Neto — Wed, 01 Oct 2025 20:02:41 +0000

Se você já lidou com flags binárias, sabe como é fácil perder o fio da meada quando o código começa a ter muitos & e |. A lógica funciona, mas a leitura rápida já se torna um desafio.

A função compareBitwise() proposta aqui, surge justamente para esse ponto: ela não elimina a complexidade, mas organiza de forma que seja mais fácil entender o que está sendo verificado. Adicionando um nível de abstração para ganhar clareza e legibilidade.

A função compareBitwise()

function compareBitwise(flags: number, flagsBuild: number = 0) {
  return {
    match(flag: number) {
      return compareBitwise(flags, flagsBuild | flag);
    },
    all(): boolean {
      return (flags & flagsBuild) === flagsBuild;
    },
    any(): boolean {
      return (flags & flagsBuild) !== 0;
    },
  };
}

Cada match adiciona uma flag ao "contexto" interno, sem precisar mexer diretamente nos bits. Depois, all() ou any() retornam se todos ou alguma das flags batem.

Exemplo de uso

Vamos criar uma constante de permissões:

const PERMISSIONS = {
  READ: 0b0001,
  WRITE: 0b0010,
  DELETE: 0b0100,
  ADMIN: 0b1000,
};

const userPermissions = PERMISSIONS.READ | PERMISSIONS.DELETE | PERMISSIONS.ADMIN;

// Verificar se o usuário pode editar e deletar
const canEditAndDelete = compareBitwise(userPermissions)
  .match(PERMISSIONS.WRITE)
  .match(PERMISSIONS.DELETE)
  .all(); // false

// Verificar se o usuário tem pelo menos uma permissão crítica
const hasCriticalPermission = compareBitwise(userPermissions)
  .match(PERMISSIONS.DELETE)
  .match(PERMISSIONS.ADMIN)
  .any(); // true

Compare com a forma tradicional usando apenas operadores bitwise:

const canEditAndDeleteTraditional =
  (userPermissions & (PERMISSIONS.WRITE | PERMISSIONS.DELETE)) ===
  (PERMISSIONS.WRITE | PERMISSIONS.DELETE);

Com compareBitwise(), a intenção do código fica explícita sem precisar interpretar operadores binários mentalmente.

Sugestões de melhoria

Hoje, o match só aceita uma flag por vez. Um desafio interessante é pensar em como permitir múltiplas flags de uma só vez, seja com múltiplos argumentos ou um array:

// Ideia de sintaxe desejada
compareBitwise(userPermissions)
  .match(PERMISSIONS.WRITE, PERMISSIONS.DELETE)
  .all();

// ou
compareBitwise(userPermissions)
  .match([PERMISSIONS.WRITE, PERMISSIONS.DELETE])
  .all();

Conclusão

A função compareBitwise() não substitui o operador bitwise, nem pretende ser a solução para tudo.
Mas, quando o código precisa deixar explícito quem pode fazer o quê, ele transforma uma expressão difícil de ler em algo que praticamente "fala por si só".

SVGs para ReactComponent com Plugin SWC - Minha Jornada com Rust e Um Pouco de Teimosia

João Neto — Thu, 03 Jul 2025 22:38:00 +0000

Há umas semanas me peguei pensando em como poderia otimizar um fluxo de build de SVGs para React, sem depender de soluções gigantes ou plugins engessados. Foi aí que nasceu a ideia de escrever meu próprio plugin para o SWC, um compilador escrito em Rust que, convenhamos, intimida bastante quem só encostou de leve na linguagem.

Minha meta era simples no papel:
Pegar um svg, passar pelo swc e gerar um componente React limpo, válido.

A realidade, claro, foi um pouco mais tortuosa, por que eu queria fazer isso sem depender do svgr e outras libs que já fazem isso.

Entendendo o monstro (ou tentando)

Primeiro veio o Rust. Embora eu já estivesse brincando com a linguagem, foi a primeira vez que precisei realmente encarar o ecossistema do swc_core, entender o mínimo sobre a árvore de sintaxe (AST), a forma como Visit e VisitMut funcionam e como a arquitetura modular (e brutal) do SWC exige que você entenda exatamente onde quer mexer.

Não sou especialista em compiladores, nem pretendo ser, mas foi gratificante ver como as peças se encaixam, mesmo que de forma amadora. Tive que desenhar árvore por árvore, pra criar o componente react com base no svg e debugar no contexto do WASM que não tem ~"console.log"~ de maneira tão fácil, e principalmente aceitar que erros de tipo em Rust não perdoam ninguém.

Modularidade que empodera (e atrapalha)

O legal (e assustador) de criar um plugin pro SWC é perceber que tudo é feito pra ser plugável, performático e modular. Isso é libertador, mas também não extremamente complicado: se você não entende bem o que está mexendo, vai quebrar seu AST todo e nada vai compilar.

Depois de alguns dias errando e recompilando e olhado os plugin prontos do SWC, consegui fazer um VisitMut que:

Troca class por className.
Converte style="..." em objeto React.
Transforma atributos com hífen (stroke-width) em strokeWidth.
Empacota tudo em um componente export default, bonitinho.

CLI, build e WASM

A parte boa: depois de pronto, compilar tudo pra WASM e rodar com o swc cli é praticamente mágico. Ter Rust + SWC + WASM rodando em npm run build te dá a sensação de ter controle sobre o compilador inteiro.

Hoje, com esse plugin, eu já consigo montar uma biblioteca de ícones SVG que viram componentes React no build. É brutalmente rápido e sem dependências extras.

Limites e próximos passos

Por enquanto, é um experimento — funciona bem no React para web, mas ainda não daria pra usar direto no React Native. Quem sabe numa v0.2 eu consiga estender isso pra gerar algo compatível com react-native-svg ou outra lib parecida.

Para quem quiser explorar

O repo é: https://github.com/joaoneto/swc-plugin-svg-component

Se quiser ver como funciona, clona, compila, brinca com cargo build e swc cli. Se surgir bug, abre issue. Se quiser mexer junto, manda PR. Se achar tudo isso insano demais pra rodar em produção, concordo. É um plugin experimental no sentido mais radical possível da palavra.

No fim das contas, foi uma experiência que me aproximou mais do Rust, do SWC e do Next.js com Turbopack.

SVGs para ReactComponent com Plugin SWC - Minha Jornada com Rust e Um Pouco de Teimosia

João Neto — Thu, 03 Jul 2025 22:38:00 +0000

Minha meta era simples no papel:
Pegar um svg, passar pelo swc e gerar um componente React limpo, válido.

A realidade, claro, foi um pouco mais tortuosa, por que eu queria fazer isso sem depender do svgr e outras libs que já fazem isso.

Entendendo o monstro (ou tentando)

Modularidade que empodera (e atrapalha)

Depois de alguns dias errando e recompilando e olhado os plugin prontos do SWC, consegui fazer um VisitMut que:

Troca class por className.
Converte style="..." em objeto React.
Transforma atributos com hífen (stroke-width) em strokeWidth.
Empacota tudo em um componente export default, bonitinho.

CLI, build e WASM

Hoje, com esse plugin, eu já consigo montar uma biblioteca de ícones SVG que viram componentes React no build. É brutalmente rápido e sem dependências extras.

Limites e próximos passos

Para quem quiser explorar

O repo é: https://github.com/joaoneto/swc-plugin-svg-component

No fim das contas, foi uma experiência que me aproximou mais do Rust, do SWC e do Next.js com Turbopack.

O repo: https://github.com/joaoneto/swc-plugin-svg-component

libuv e Lua

João Neto — Tue, 28 Jan 2025 01:00:09 +0000

Criei um projeto chamado lua-libuv e gostaria de compartilhar minha experiência. A ideia inicial era testar as possibilidades de usar a biblioteca libuv (uma biblioteca de I/O assíncrono escrita em C) para criar um servidor HTTP extremamente simples, sem utilizar todo o poder da libuv, já que não sei nada da linguagem C.

Com a ajuda do ChatGPT, gerei a base do que atualmente é o http.c e, com um pouco de perseverança, consegui fechar as conexões e liberar memória na hora certa, pois enfrentei vários problemas, como o servidor simplesmente fechar a conexão e quebrar o programa principal. Tentei criar um streaming para enviar chunks, que funcionou (mas esse foi o ponto que quebrava a thread principal hehehe), só que acabei abandonando para chegar a um fim, pois meu objetivo não era me aprofundar em C.

Acabei criando um ambiente onde é possível executar scripts Lua dentro de um servidor HTTP, utilizando a libuv para gerenciar as operações assíncronas. O objetivo inicial era apenas criar o servidor HTTP, mas acabei criando uma estrutura para rodar scripts Lua, o que foi uma boa evolução do projeto.

Ainda não testei no Linux, então não sei se funcionará com apenas o comando make, mas, de qualquer forma, é muito satisfatório ver o progresso e o objetivo alcançado até aqui. Além disso, o projeto pode servir como um ponto de partida para quem quiser construir algo mais elaborado utilizando libuv e Lua.

Se alguém se interessar ou quiser colaborar, sinta-se à vontade para testar ou dar sugestões. A ideia é ajudar quem quer explorar mais essas tecnologias.

O código está disponível no repositório.

[update]
Corrigido build e execução dos scripts lua para ambiente linux, testado no Ubuntu.

Desvendando a Monad Result em JavaScript

João Neto — Thu, 28 Mar 2024 22:13:29 +0000

Introdução:

Ao desenvolver em JavaScript, frequentemente nos deparamos com situações em que precisamos lidar com operações que podem ter sucesso ou falhar. Para facilitar esse cenário, podemos recorrer à monad Result, uma ferramenta poderosa que nos permite lidar com essas situações de forma elegante e segura. Neste artigo, vamos explorar como criar e usar a classe Result em JavaScript, inspirada no Result do Rust, e entender como ela se encaixa no conceito de monad.

O que é a Monad Result?

A monad Result encapsula um valor que pode representar um resultado bem-sucedido ou um erro. É como uma caixinha que nos permite tratar operações que podem falhar de forma mais estruturada e previsível. Se você já está familiarizado com o Result em Rust, vai perceber que a ideia é bem similar.

Criando a Classe Result em JavaScript:

Vamos dar uma olhada na implementação básica da classe Result em JavaScript:

class Result {
    constructor(value, error) {
        this.value = value;
        this.error = error;
    }

    static Ok(value) {
        return new Result(value, null);
    }

    static Err(error) {
        return new Result(null, error);
    }

    map(fn) {
        return this.error ? this : new Result(fn(this.value), null);
    }

    andThen(fn) {
        return this.error ? this : fn(this.value);
    }

    catch(fn) {
        return this.error ? fn(this.error) : this;
    }

    unwrap() {
        if (this.error) {
            throw new Error(this.error);
        }
        return this.value;
    }
}

// Definindo uma função para dividir dois números
function dividir(a, b) {
    // Verificando se o divisor é zero
    if (b === 0) {
        // Se for, retornamos um Result.Err com uma mensagem de erro
        return Result.Err("Não é possível dividir por zero.");
    } else {
        // Caso contrário, retornamos um Result.Ok com o resultado da divisão
        return Result.Ok(a / b);
    }
}

// Exemplo de uso da função dividir
const resultadoDivisao = dividir(10, 2)
    .map(resultado => resultado * 3) // Multiplicando o resultado por 3
    .andThen(resultado => Result.Ok(resultado + 5)) // Adicionando 5 ao resultado
    .unwrap(); // Desembrulhando o valor final

console.log(resultadoDivisao); // Resultado = 20

// Tentativa de dividir por zero, erro propagado
const resultadoVoid = dividir(10, 0)
    .map(resultado => resultado * 3) // Não será executado devido ao erro
    .andThen(resultado => Result.Ok(resultado + 5)) // Não será executado devido ao erro

// Como não foi feito unwrap, o erro não foi tratado e permanece no objeto Result.
console.log(resultadoVoid) // Result { value: null, error: 'Não é possível dividir por zero.' }

// Tentativa de dividir por zero, erro propagado e tratado com try-catch
try {
    dividir(10, 0)
        .map(resultado => resultado * 3) // Não será executado devido ao erro
        .andThen(resultado => Result.Ok(resultado + 5)) // Não será executado devido ao erro
        .unwrap();
} catch (error) {
    console.log(error.message); // A mensagem de erro é capturada e exibida: "Não é possível dividir por zero."
}

// Tentativa de dividir por zero, erro capturado e manipulado
const resultadoDivisaoPorZero = dividir(10, 0)
    .map(resultado => resultado * 3) // Não será executado devido ao erro
    .andThen(resultado => Result.Ok(resultado + 5)) // Não será executado devido ao erro
    .catch((e) => Result.Err(`Ocorreu um erro: ${e}`)); // O erro é capturado e uma mensagem personalizada é retornada

console.log(resultadoDivisaoPorZero); // Result { value: null, error: 'Ocorreu um erro: Não é possível dividir por zero.' }

Conclusão:

A monad Result em JavaScript é uma ferramenta valiosa para lidar com situações de sucesso ou falha de forma estruturada e controlada. Ao entender como criar e usar essa classe, podemos escrever código mais robusto e previsível em nossos projetos.

Se você quiser saber mais sobre monads e programação funcional, recomendo dar uma olhada nestes links:

Simplificando o Desenvolvimento: Como Injeção de Dependências e Contêineres Transformam o Código

João Neto — Thu, 21 Mar 2024 15:52:23 +0000

Quer simplificar o desenvolvimento de software e tornar seu código mais robusto? Descubra como a Injeção de Dependências e os Contêineres podem revolucionar sua abordagem de codificação.

Modularidade e manutenção de código é essencial para garantir um sistema robusto e escalável. Uma técnica poderosa para alcançar esses objetivos é a Injeção de Dependências (DI), combinada com o uso de Contêineres de Injeção de Dependências.

O Que é Injeção de Dependências?

Injeção de Dependências (DI) é um princípio de design que visa reduzir o acoplamento entre componentes, permitindo que suas dependências sejam fornecidas por uma fonte externa. Isso promove a reutilização, teste e manutenção do código.
Para entender mais sobre DI e seus benefícios, você pode conferir este link.

Contêiner de Injeção de Dependências?

É uma estrutura que gerencia e fornece dependências em todo o sistema. Ele atua como um repositório centralizado para todas as dependências do aplicativo, eliminando a necessidade de configurar manualmente as dependências em cada componente.

Implementando um Contêiner

A implementação de um Contêiner de Injeção de Dependências pode variar de acordo com a linguagem de programação e o ambiente de desenvolvimento. No entanto, o princípio básico permanece o mesmo: configurar todas as dependências do aplicativo em um local centralizado e fornecê-las conforme necessário.

Com o uso de Contêineres de Injeção de Dependências, podemos simplificar o desenvolvimento de software, tornando nosso código mais modular, testável e fácil de manter.

Espero que este conteúdo seja útil para entender a importância da Injeção de Dependências e dos Contêineres de Injeção de Dependências no desenvolvimento de software moderno.

Exemplo de Implementação do Contêiner em JavaScript

const Container = {
  dependencies: {},
  set: function (key, value) {
    this.dependencies[key] = value;
    return this;
  },
  get: function (key) {
    const dependency = this.dependencies[key];
    if (typeof dependency === 'function') {
      // Se a dependência for uma função, invocamos ela, passando o próprio contêiner para possível injeção de dependências internas
      return dependency(this);
    }
    return dependency;
  },
};

// Exemplo de uso:

// Configurando o contêiner
const appContainer = Object.create(Container);

// Configurando dependências
appContainer
  .set('logger', () => console.log)
  .set('apiService', (container) => {
    // Obtendo dependências
    const api = new ApiService(container.get('logger'));
    return api;
  });

// Obtendo dependências
const logger = container.get('logger');
const apiService = container.get('apiService');

Neste exemplo, estamos implementando um contêiner de injeção de dependências simples em JavaScript. Ele possui métodos set para definir dependências e get para obter dependências. Quando uma dependência é uma função, o contêiner a invoca, permitindo a injeção de dependências internas.

Benefícios do Uso de Contêineres

O uso de Contêineres de Injeção de Dependências proporciona diversos benefícios para o desenvolvimento de software:

Desacoplamento: Os componentes do sistema se tornam independentes de suas implementações de dependência, facilitando a substituição e a manutenção do código.

Teste: A DI simplifica os testes unitários, permitindo a injeção de dependências de teste em vez de dependências reais durante os testes.

Reutilização de Código: Os componentes se tornam mais reutilizáveis, pois suas dependências são fornecidas externamente, não estando vinculadas a uma implementação específica.

Manutenção: A modularidade promovida pelos Contêineres torna o código mais fácil de entender, modificar e manter ao longo do tempo.

Conclusão:

Agora que você entende a importância da Injeção de Dependências e dos Contêineres de Injeção de Dependências, está pronto para simplificar seu processo de desenvolvimento de software. Experimente esses conceitos em seu próximo projeto e compartilhe suas experiências aqui.

APIs com Guarapi e HTTP/2

João Neto — Thu, 15 Feb 2024 17:35:24 +0000

O HTTP/2 é uma evolução significativa em relação ao seu predecessor, o HTTP/1.1, proporcionando melhorias notáveis na eficiência da comunicação entre clientes e servidores. Neste artigo, exploraremos como o Guarapi, um servidor HTTP para Node.js, oferece suporte ao HTTP/2 e por que a utilização do TLS é fundamental nesse contexto.

Motivos para o Uso do TLS com HTTP/2

O HTTP/2, por padrão, é projetado para ser seguro, e é altamente recomendável utilizar o TLS (Transport Layer Security) para garantir a integridade e a confidencialidade dos dados durante a comunicação. Além disso, muitos navegadores modernos só permitem o uso do HTTP/2 sobre TLS, tornando essencial a implementação desse protocolo de segurança.

No código abaixo, observe como o Guarapi configura o servidor para utilizar o TLS, fornecendo os certificados necessários:

const certs = {
  key: fs.readFileSync(path.resolve('./cert/key.pem')),
  cert: fs.readFileSync(path.resolve('./cert/cert.pem')),
};

const app = guarapi({
  serverOptions: {
    isSSL: true,
    isHTTP2: true,
    allowHTTP1: true,
    ...certs,
  },
});

Suporte ao HTTP/2 no Guarapi

O Guarapi simplifica a implementação do HTTP/2, oferecendo uma configuração clara e direta para habilitar esse protocolo de comunicação eficiente. Ao estabelecer o servidor com isHTTP2: true, você coloca sua aplicação na vanguarda das tecnologias web, proporcionando uma experiência mais ágil aos usuários finais.

Servindo Arquivos Estáticos com HTTP/2: Melhores Práticas

Ao considerar a entrega de arquivos estáticos via HTTP/2, é importante explorar alternativas que otimizem o desempenho. Uma abordagem comum é evitar a transmissão desses arquivos no mesmo socket do servidor Guarapi, buscando soluções mais eficientes. Isso pode ser particularmente crucial em ambientes de produção com alto tráfego.

Uma possível abordagem para aprimorar a entrega de arquivos estáticos no Guarapi é o desenvolvimento de um plugin específico. Esse plugin pode ser projetado para lidar com a transmissão de arquivos estáticos de maneira performática, aproveitando os benefícios do HTTP/2.

Explorar essas otimizações pode resultar em uma experiência de usuário mais rápida e eficiente, aproveitando ao máximo as vantagens do HTTP/2. Lembre-se de adaptar essas práticas conforme as necessidades específicas do seu projeto.

Ao adotar o HTTP/2 com Guarapi e TLS, você estará preparando sua aplicação para um desempenho maior e alinhada às melhores práticas da web moderna.

Recomendações e Recursos Adicionais

Recomendamos a consulta à documentação do Node.js sobre a compatibilidade do HTTP/2, fornecendo links específicos para as seções relevantes:

Essas referências são inestimáveis para aprofundar o entendimento sobre as nuances do HTTP/2 no contexto do Node.js. Elas oferecem insights adicionais aos desenvolvedores que desejam explorar a fundo as melhores práticas e otimizações. Ao incorporar o HTTP/2 com Guarapi e TLS, você estará preparando sua aplicação para um desempenho excepcional, alinhado às práticas mais recentes da web moderna.

Nossas redes:

Plataforma	Link
Reddit	Guarapi Subreddit
Daily.dev	Daily.dev Invite
Discord	Discord Invite
Repositório	Guarapi no GitHub

Os Bastidores do Guarapi - Framework Modular

João Neto — Thu, 08 Feb 2024 14:08:50 +0000

Navegando no Futuro: Frameworks Modulares e as Engrenagens das Prioridades

Vamos explorar mais a fundo a onda dos frameworks modulares, focando especialmente no Guarapi, que está na dianteira dessa revolução. Vamos entender por que a ordem dos plugins não é automática e como isso abre portas para um controle dinâmico via CLI ou até mesmo um admin frontend que ainda está na mesa de ideias.

1. Flexibilidade nos Trilhos com o Guarapi:

No universo dos frameworks modulares, o Guarapi é tipo o maestro da flexibilidade. Com sua abordagem modular, é possível moldar a aplicação conforme o projeto pede, e os plugins entram em cena para um upgrade personalizado.

2. Controle Manual dos Plugins:

A não ordenação automática de plugins no Guarapi é como ter o controle total do palco. Cada desenvolvedor decide a ordem de entrada dos plugins, garantindo que a performance seja um espetáculo otimizado. Isso é puro controle criativo!

3. Reuso de Plugins com a Vibe do Guarapi:

A comunidade Guarapi compartilha a visão de reuso e troca de ideias. Os plugins podem ser como peças valiosas que você pode encaixar conforme o necessário, tudo alinhado com a proposta modular e expansível do Guarapi.

4. Testabilidade na Prática:

A proposta do Guarapi, com seus plugins sob controle, facilita a testabilidade. Os testes unitários podem ser afiados para cada plugin, garantindo uma execução suave e sem tropeços.

5. Admin Frontend em Potencial:

A cereja no bolo é a ideia de um admin frontend para controlar plugins em tempo de execução. Imagina só, conectar e desconectar plugins como quem troca de figurino no backstage. O Guarapi está semeando a ideia de um controle dinâmico para os devs.

6. Rumo ao Futuro:

O Guarapi, com sua abordagem modular e controle manual de plugins, está apontando para o futuro. A visão de um admin frontend adiciona um toque extra de inovação. O controle em tempo de execução é como ter as rédeas da experiência de desenvolvimento nas mãos.

Conclusão: Conduzindo a Orquestra do Desenvolvimento

Os frameworks modulares, especialmente o Guarapi, abrem portas para uma era de controle e personalização no desenvolvimento. Controlar manualmente a ordem dos plugins é uma jogada inteligente, proporcionando um espetáculo de performance otimizado. E a visão de um admin frontend no Guarapi? Isso pode ser um divisor de águas na flexibilidade e no controle em tempo real. Vamos ficar de olho nesse enredo emocionante!

Nossas redes:

Plataforma	Link
Reddit	Guarapi Subreddit
Daily.dev	Daily.dev Invite
Discord	Discord Invite
Repositório	Guarapi no GitHub

Implementando um Plugin de Autenticação para Guarapi

João Neto — Wed, 10 Jan 2024 18:31:58 +0000

Olá!

Gostaria de compartilhar uma Prova de Conceito (POC) de um plugin de autenticação em desenvolvimento para o Guarapi. Este plugin visa oferecer funcionalidades de autenticação e renovação de tokens JWT.

Para mais informações e para colaborar, acesse nosso Discord Guarapi Development e confira o GitHub do Guarapi.

Aqui está uma breve amostra do código do plugin:

import { Plugin, Request } from 'guarapi';
import { Methods } from 'guarapi/dist/lib/router';
import { sign } from 'jsonwebtoken';

interface SingConfig<P extends { sub: string | number }> {
  route: string;
  getJWTPayload: (req: Request) => Promise<P>;
}

export interface GuarapiAuthPluginConfig<P extends { sub: string | number }> {
  signIn?: SingConfig<P>;
  refreshToken?: SingConfig<P>;
  salt: string;
  tokenExpiresIn: string;
  refreshTokenExpiresIn: string;
  issuer: string;
  audience: string;
}

export default function guarapiAuthPlugin<P extends { sub: string | number }>(
  guarapiAuthPluginConfig: GuarapiAuthPluginConfig<P>,
) {
  const { salt, audience, issuer, tokenExpiresIn, refreshTokenExpiresIn, signIn, refreshToken } =
    guarapiAuthPluginConfig;

  const routesMap: Record<string, SingConfig<P> | undefined> = {
    [signIn?.route || '']: signIn,
    [refreshToken?.route || '']: refreshToken,
  };

  async function getTokens(req: Request, route: SingConfig<P>) {
    const { sub, ...jwtPayload } = await route.getJWTPayload(req);

    return {
      token: sign({ sub, ...jwtPayload }, salt, {
        expiresIn: route === signIn ? tokenExpiresIn : refreshTokenExpiresIn,
        audience,
        issuer,
      }),

      refreshToken: sign({ sub, ...jwtPayload }, salt, {
        expiresIn: refreshTokenExpiresIn,
        audience,
        issuer,
      }),
    };
  }

  const plugin: Plugin = (app) => {
    app.use(async (req, res, next) => {
      const route = routesMap[req.url || ''];
      const method = req.method?.toLocaleLowerCase();

      if (route && method === Methods.POST) {
        const tokens = await getTokens(req, route);
        res.json(tokens);
        return;
      }

      next();
    });

    return {
      name: 'guarapiAuthPlugin',
    };
  };

  return plugin;
}

Este plugin permite configurar rotas de autenticação e renovação de tokens JWT, adaptáveis às necessidades do projeto. Ele utiliza o pacote jsonwebtoken para gerar os tokens com base nas configurações fornecidas.

A configuração básica para este plugin é a seguinte:

import { Guarapi, bodyParserPlugin, middlewarePlugin } from 'guarapi';
import guarapiAuthPlugin, { GuarapiAuthPluginConfig } from './guarapi-auth-plugin';

interface PayloadRequest {
  userId: string;
}

export default async function initPlugins(app: Guarapi) {
  const authConfig: GuarapiAuthPluginConfig<{ sub: string; userId: string }> = {
    signIn: {
      route: '/auth/signin',
      getJWTPayload: async (req) =>
        Promise.resolve({ sub: 'teste', userId: (req.body as PayloadRequest)?.userId }),
    },
    refreshToken: {
      route: '/auth/refresh',
      getJWTPayload: async (req) =>
        Promise.resolve({ sub: 'teste', userId: (req.body as PayloadRequest)?.userId }),
    },
    audience: 'teste',
    issuer: 'issuer-1',
    salt: 'secret',
    refreshTokenExpiresIn: '24h',
    tokenExpiresIn: '1h',
  };

  app.plugin(bodyParserPlugin);
  app.plugin(middlewarePlugin);
  app.plugin(guarapiAuthPlugin(authConfig));
}

Estou buscando feedback da comunidade sobre a estrutura, a lógica de funcionamento e possíveis melhorias que podem ser implementadas neste plugin. Sintam-se à vontade para discutir e compartilhar suas opiniões, sugestões ou dúvidas relacionadas a esta POC.

Agradeço antecipadamente por qualquer contribuição ou feedback que possam oferecer!

Nossas redes:

Plataforma	Link
Reddit	Guarapi Subreddit
Daily.dev	Daily.dev Invite
Discord	Discord Invite
Repositório	Guarapi no GitHub

🚀 Crie Aplicativos Web com o Guarapi Rapidamente!

João Neto — Sun, 22 Oct 2023 04:39:15 +0000

Introdução:

Olá! Temos o prazer de anunciar o lançamento da Versão 1.0 do Guarapi e o starter kit @guarapi/create-guarapi-app, uma ferramenta que simplifica o processo de criação de aplicativos web com o Guarapi framework. Se você é um desenvolvedor em busca de uma estrutura eficaz e elegante para criar aplicativos Node.js, esta é a notícia que você estava esperando!

Como Começar:

Usar o @guarapi/create-guarapi-app é fácil. Basta criar um novo aplicativo Guarapi com este único comando:

pnpm create @guarapi/guarapi-app

Escolha um exemplo de projeto de nossos exemplos Guarapi

Como Contribuir:

Estamos sempre abertos a contribuições e feedback da comunidade. Se você encontrar problemas ou tiver sugestões para melhorias, não hesite em abrirmos uma issue no GitHub. Valorizamos sua opinião!

Guarapi v0.1.0: Revolucionando o Desenvolvimento Web com Node.js

João Neto — Wed, 13 Sep 2023 05:07:00 +0000

É com grande empolgação que compartilho as últimas atualizações do Guarapi. Estamos comprometidos em tornar o desenvolvimento web mais simples e eficiente, e nossa mais recente versão, a v0.1.0, traz algumas melhorias empolgantes.

Novidades em Destaque

Plugin de Rotas Integrado

A principal adição nesta versão é a integração de um plugin de rotas robusto. Agora, você pode definir rotas para sua aplicação web de maneira flexível e intuitiva. Lida com diferentes métodos HTTP e padrões de URL com facilidade, economizando tempo e esforço no desenvolvimento de rotas complexas. Dê uma olhada na nossa documentação para aprender como começar a usar esse novo recurso!

Hook de Erro

Outra grande melhoria é a inclusão do hook de erro. Ele permite que você gerencie erros de maneira elegante durante o processamento de solicitações. Seja para registrar erros ou fornecer respostas de erro adequadas, o hook de erro é uma ferramenta essencial para tornar suas aplicações mais robustas e confiáveis.

Próximos Passos

Estamos empolgados com o progresso do Guarapi até agora, mas nosso trabalho está longe de terminar. Aqui estão alguns dos próximos passos que planejamos:

Melhorias Contínuas: Continuaremos aprimorando o Guarapi para oferecer uma experiência de desenvolvimento ainda melhor. Esperamos adicionar mais recursos úteis e aprimorar a usabilidade.
Adicionar Testes: A qualidade é nossa prioridade. Estamos planejando adicionar testes abrangentes para garantir que o Guarapi seja confiável e estável em todos os cenários.
Novas Funcionalidades: Estamos sempre abertos a ideias e contribuições da comunidade. Se você tiver sugestões ou desejar adicionar novos recursos, fique à vontade para contribuir para o projeto.

Estamos entusiasmados com o que o futuro reserva para o Guarapi e mal podemos esperar para ver o que você construirá com essa ferramenta poderosa.

Junte-se a nós na jornada do Guarapi, explore nossa documentação e fique à vontade para contribuir para o projeto no GitHub. Seja parte desta comunidade amigável e inclusiva.

Fique atento às atualizações e evoluções deste framework. Juntos, podemos fazer a diferença no mundo do desenvolvimento web!

Guarapi - Framework Brasileiro

João Neto — Tue, 29 Aug 2023 02:48:43 +0000

Guarapi - Framework Brasileiro

Descubra o Guarapi, um framework revolucionário para desenvolvimento web em Node.js. Neste artigo, mergulhamos fundo no estágio atual de desenvolvimento do Guarapi, explorando funcionalidades emocionantes e oportunidades de colaboração. Acompanhe o progresso deste projeto de código aberto e saiba como fazer parte dessa jornada.

Repositório no GitHub: Guarapi GitHub Repository

Exemplo

import { IncomingMessage, ServerResponse } from "http";
import guarapi, { middleware, logger } from "guarapi";

const app = guarapi();

app.plugin(middleware);
app.plugin(logger);

app.use(async (req, res, next) => {
    app.logger("info", "My debug msg");
    next();
});

app.use(async (req: IncomingMessage, res: ServerResponse) => {
    res.end("ok");
});

app.listen(3000, "0.0.0.0", () => {
    console.log("> Running: http://localhost:3000");
});

O código de exemplo demonstra a estrutura básica de um aplicativo Guarapi. Vamos dar uma olhada nos principais componentes:

Imports: O código começa importando os módulos http e o próprio guarapi. Ele também importa os módulos de middleware e logger.
Criação de uma instância Guarapi: O código cria uma instância do Guarapi chamada app.
Adição de Middleware: O código adiciona dois plugins ao Guarapi: middleware e logger.
Definição de Rotas: Duas rotas são definidas usando o método app.use(). A primeira rota registra uma mensagem de log usando o logger do Guarapi e, em seguida, chama o próximo middleware. A segunda rota simplesmente envia uma resposta "ok" para o cliente. Posteriormente, teremos mais formas de definir rotas.
Inicialização do Servidor: O código inicia o servidor na porta 3000 e no endereço "0.0.0.0".

Funcionalidades Principais

Podemos destacar as seguintes funcionalidades principais do Guarapi até o momento:

Middleware: O Guarapi suporta a inclusão de middleware, como demonstrado pela adição dos plugins middleware e logger. Isso permite que desenvolvedores personalizem o processamento de solicitações HTTP.
Logging: O framework possui um sistema de registro integrado. O exemplo mostra como registrar mensagens de log com diferentes níveis (no caso, "info").
Middleware (Tratamento de Rotas raiz): Rotas são definidas usando o método app.use(), permitindo que os desenvolvedores definam como as solicitações HTTP devem ser manipuladas.

Próximos Passos

Agora, imagine as possibilidades! Você pode fazer parte do futuro deste framework emocionante:

Adição de Recursos: Expandir a funcionalidade do framework adicionando mais recursos, como suporte a autenticação, validação de entrada e roteamento avançado.
Documentação Detalhada: Criar documentação detalhada para que outros desenvolvedores possam entender e utilizar facilmente o Guarapi.
Testes Unitários e de Integração: Implementar testes para garantir a robustez e confiabilidade do framework.
Comunidade e Colaboração: Encorajar a participação da comunidade e receber contribuições para o projeto. Vamos construir algo incrível juntos!

Conclusão

O Guarapi é mais do que um framework - é uma oportunidade de inovação e colaboração. Com um compromisso com a flexibilidade e uma visão ambiciosa, o Guarapi promete simplificar o desenvolvimento de aplicativos web em Node.js. Junte-se a nós nesta emocionante jornada de criação e transformação!

Fique atento às atualizações e evoluções deste framework. Juntos, podemos fazer a diferença no mundo do desenvolvimento web!