Roteiro de Desenvolvimento

Esta atualização garantirá suporte completo à geração de projetos com base no .NET 10, assim que a nova versão for oficialmente lançada pela Microsoft.

Atualmente, o Lino gera projetos com base no .NET 9, aproveitando todos os recursos disponíveis da plataforma, incluindo melhorias em performance, recursos avançados do C# 13 e integração moderna com ASP.NET Core.

O objetivo desta futura versão é oferecer suporte imediato ao .NET 10 com templates atualizados, configurações de Target Framework adequadas, e scaffolding pronto para novos recursos da linguagem e runtime.

Geração automatizada de testes com suporte a dois níveis principais:

Testes Unitários:
Criação de testes para classes e métodos individuais, com foco na lógica de negócios.

Testes de Integração:
Criação de testes para verificar a integração entre componentes, simulando interações com bancos de dados e serviços externos.

Implementação da geração automática de arquivos .http, com o objetivo de facilitar o teste e a documentação de endpoints REST em ambientes de desenvolvimento.

Sistema de controle de acesso baseado em permissões (PBAC) utilizando Policies do ASP.NET Core.
As permissões são criadas automaticamente por Source Generators e registradas como Policies no .NET.
Cada serviço que utiliza essas permissões dispara eventos que alimentam e atualizam automaticamente a base de permissões do sistema.

Principais Características:
_ Geração automática de permissões via Source Generators
_ Registro automático de Policies no ASP.NET Core
_ Atualização dinâmica da base de permissões via eventos/mensageria
_ Suporte a RBAC híbrido, combinando simplicidade de papéis com granularidade de permissões

Benefícios:
_ Máxima performance e escalabilidade
_ Gestão automatizada e manutenção simplificada
_ Flexibilidade para diferentes cenários de segurança

Implementação de suporte nativo ao tipo IFormFile para endpoints criados com Minimal APIs. Esta funcionalidade permitirá a geração automatizada de rotas com upload de arquivos, com:

_ Definição de endpoints com suporte a uploads via multipart/form-data;
_ Validação automática de tipos MIME e tamanhos máximos permitidos;
_ Suporte a armazenamento local e integração com serviços de nuvem como Azure Blob Storage e AWS S3;

Ideal para aplicações que necessitam de upload seguro e performático de arquivos como imagens, documentos e mídia em geral.

A partir desta versão, o Lino CLI passa a realizar merge automático inteligente de arquivos gerados. Antes, os arquivos criados pelo Lino substituíam diretamente os existentes, podendo sobrescrever alterações feitas manualmente pelo desenvolvedor.

Agora, com a nova estratégia de 3-way merge (arquivo original gerado, versão editada pelo usuário e novo arquivo gerado), o Lino consegue preservar as personalizações e ainda aplicar atualizações estruturais do template.

Benefícios desta abordagem:
_ Evita sobrescritas acidentais de código manual.
_ Facilita a evolução contínua de projetos baseados em templates.
_ Reduz conflitos manuais durante atualizações.
_ Melhora a integração entre customizações locais e evolução do framework.

Agora, os projetos gerados pelo Lino CLI podem registrar Minimal APIs automaticamente utilizando a biblioteca Tolitech.Presentation.API.Generators, baseada em Source Generators.

Essa abordagem substitui a necessidade de:
_ Registrar manualmente cada endpoint via MapGet, MapPost, etc.
_ Usar Reflection para escanear e mapear rotas — algo custoso em performance.

Com o uso de Source Generators, o mapeamento é feito em tempo de compilação, gerando código otimizado, limpo e rastreável.

Principais benefícios:
_ Elimina a verbosidade e repetição do registro manual de rotas.
_ Remove a necessidade de Reflection, reduzindo consumo de CPU e memória.
_ Melhora a organização do código e separação de responsabilidades.
_ Geração automática e segura de rotas com validação de compilação.
_ Facilita manutenção e escalabilidade do projeto.

Agora utilizamos a biblioteca Tolitech.DependencyInjection.Generators, que substitui a abordagem baseada em Reflection da Tolitech.DependencyInjection.Extensions.

Essa nova biblioteca aproveita o recurso de Source Generators do .NET para gerar automaticamente os registros de dependências em tempo de compilação.

Isso proporciona diversas vantagens:
_ Eliminação de Reflection em tempo de execução, melhorando a performance da aplicação.
_ Geração de código mais previsível e rastreável.
_ Compilação mais segura, com erros detectados antecipadamente.
_ Integração nativa com o pipeline de build do .NET.

Passamos a utilizar o Central Package Manager (CPM), uma abordagem moderna para o gerenciamento de pacotes NuGet em soluções com múltiplos projetos. Com ele, todas as versões de pacotes são definidas centralmente no arquivo Directory.Packages.props, eliminando inconsistências e facilitando atualizações seguras e coordenadas. Isso reduz erros causados por divergências de versão entre projetos, melhora a rastreabilidade e simplifica o processo de atualização de dependências em larga escala.

Lino agora gera soluções no novo formato .slnx, uma evolução moderna do tradicional .sln.
Baseado em XML, o .slnx foi adotado por ser mais legível por humanos e ferramentas, reduzindo a complexidade para integrações com sistemas externos e pipelines de CI/CD.

Além disso, sua estrutura mais limpa melhora significativamente o controle de versão — mudanças são mais previsíveis e fáceis de revisar.
Essa mudança acompanha a direção futura do ecossistema .NET, promovendo maior interoperabilidade, extensibilidade e automação no desenvolvimento de projetos.

A assinatura Community passa a oferecer suporte à geração de projetos com base no .NET 9 e Aspire 9.2.1, permitindo que usuários explorem os recursos da plataforma de forma gratuita e técnica.

Esta liberação contempla:
_ Criação de serviços e entidades com scaffolding automatizado;
_ Seleção do banco de dados e configuração inicial completa;
_ Geração funcional até o estágio de EF Core Migrations.

Embora funcionalidades avançadas como microsserviços e monólitos modulares estejam restritas a planos pagos, esta versão oferece uma base sólida para avaliação da arquitetura gerada, qualidade do código, e integração com o ecossistema .NET moderno.

A CLI agora oferece o comando lino database migrations add para facilitar a criação de migrações para qualquer serviço ou módulo do projeto.

Esse recurso automatiza a geração de scripts de migração vinculados à versão do build e permite a documentação das alterações de forma consistente.

Principais benefícios:
_ Criação rápida de migrações por serviço ou módulo, com comandos simples e diretos.
_ Geração automática de scripts .sql compatíveis com o versionamento do projeto.
_ Facilita o controle de versão de banco de dados mesmo em arquiteturas distribuídas.
_ Padroniza e documenta alterações estruturais do banco de forma segura e audível.
_ Integração natural com o fluxo de build e deploy da aplicação.

A nova funcionalidade de versionamento permite listar versões existentes e realizar o bump de versão em serviços e aplicações web geradas pela ferramenta, seguindo a convenção SemVer (Semantic Versioning). Isso garante mais rastreabilidade, padronização e controle no ciclo de releases.

Por meio do comando version, é possível definir e atualizar facilmente o número da versão de cada serviço ou aplicação, facilitando auditorias e incorporando boas práticas ao fluxo de desenvolvimento.

O comando build também foi aprimorado para gerar imagens Docker já com a tag da versão definida, simplificando o empacotamento e preparando as aplicações para publicação.

Essas melhorias aumentam a consistência e previsibilidade no gerenciamento de releases, oferecendo mais transparência para equipes de desenvolvimento e operações.

Personalizar quais propriedades serão consideradas na geração de artefatos do tipo Command (Post, Put, Patch) e Query (Get).

Esta funcionalidade oferece:
_ Interface interativa na CLI para seleção de propriedades durante o processo de scaffolding de entidades;
_ Geração automática de objetos com apenas os campos selecionados para input/output;
_ Suporte completo para customização de payloads em APIs REST, aumentando a flexibilidade e controle sobre os dados trafegados;
_ Integração com a validação e os contratos de dados gerados, respeitando regras de obrigatoriedade e consistência.

Essa melhoria visa oferecer maior granularidade na modelagem dos artefatos, permitindo ao desenvolvedor controlar com precisão o que será exposto, persistido ou consultado por meio da arquitetura gerada pela CLI.

Foi implementado um mecanismo automático de versionamento e backup de arquivos no Lino CLI, com o objetivo de garantir segurança e rastreabilidade em processos de geração e sobrescrita de arquivos.

Todos os arquivos gerados são armazenados na pasta /.lino/files/.../received/, garantindo que cada arquivo seja organizado de forma temporal e facilmente localizável.

Arquivos que são substituídos permanecem armazenados na pasta /.lino/files/.../replaced/, possibilitando a recuperação de versões anteriores quando necessário. Essa estrutura de backup proporciona maior controle e segurança, permitindo uma auditoria completa dos arquivos gerados, especialmente em ambientes de desenvolvimento colaborativo e automatizado.

Implementação completa de autenticação e autorização para projetos frontend e backend, com base em JWT (JSON Web Tokens) e controle granular de permissões por meio de Authorization Policies personalizadas do ASP.NET Core.

Destaques:
_ Login seguro com emissão e validação de JWTs.
_ Autorização baseada em políticas customizadas (Claims e Roles).
_ Integração automática entre APIs e frontends (Blazor) gerados.
_ Proteção de rotas e componentes com base nas permissões do usuário.

Vantagens:
_ Segurança robusta para aplicações modernas.
_ Padronização do modelo de acesso por perfil e domínio.
_ Experiência segura e integrada entre as camadas da aplicação.
_ Facilidade para estender ou adaptar conforme o cenário da empresa.

Agora é possível adicionar um ou mais frontends aos projetos gerados, com suporte inicial para Blazor Web Apps — incluindo os modelos Server e WebAssembly.

Esses frontends são automaticamente integrados com as APIs geradas pela ferramenta, permitindo a criação de páginas CRUD completas com chamadas diretas aos endpoints backend e persistência no banco de dados.

Destaques:
_ Geração de UI com base nas entidades do domínio.
_ Comunicação nativa com as APIs geradas.
_ Funcionalidade de ponta a ponta: frontend, backend e banco de dados funcionando juntos.
_ Possibilidade de múltiplos frontends no mesmo projeto (ex: admin, portal, público).

Benefícios:
_ Agilidade no desenvolvimento de interfaces.
_ Menos retrabalho e integração manual.
_ Padrão unificado de navegação, estilo e acesso a dados.
_ Maior produtividade com geração automática de páginas CRUD.

Implementamos o padrão Transactional Outbox para garantir confiabilidade no envio de eventos de integração. Ao invés de publicar o evento diretamente durante a transação da aplicação, agora ele é registrado em uma tabela específica dentro da mesma transação do banco de dados.

Posteriormente, um background job lê essa outbox e realiza o disparo real do evento.

Vantagens desta abordagem:
_ Garante consistência entre alterações no banco e publicação de eventos.
_ Evita perda de mensagens em caso de falhas intermediárias.
_ Permite controle de reenvio e auditoria de eventos publicados.
_ Alinha-se a boas práticas de arquitetura orientada a eventos e microsserviços.

Foi adicionada a opção de incluir Background Jobs nos serviços gerados — sejam eles simples ou modulares — utilizando a biblioteca Hangfire.

Com isso, os projetos passam a ter agendamento e execução de tarefas em segundo plano de forma nativa, incluindo:
_ Execução recorrente (cron), agendada ou imediata.
_ Monitoramento via painel de controle integrado.
_ Persistência e reprocessamento de jobs com segurança.

Esse mecanismo também pode ser utilizado em conjunto com o Transactional Outbox Pattern, garantindo o disparo confiável de eventos de integração mesmo em falhas parciais ou cenários distribuídos.

Principais vantagens:
_ Automatização de tarefas recorrentes e demoradas sem bloquear o fluxo principal.
_ Alta resiliência e persistência das tarefas em background.
_ Pronta integração com o padrão Outbox para eventos confiáveis.
_ Fácil configuração e personalização de jobs por serviço.
_ Dashboard embutido para inspeção e controle de execuções.

Adicionada a possibilidade de configurar suporte à mensageria assíncrona com RabbitMQ, utilizando a abstração e recursos avançados do MassTransit.

Com isso, os serviços gerados podem se comunicar de forma desacoplada e resiliente, utilizando eventos e comandos distribuídos.

Destaques da integração:
_ Configuração automatizada do transporte com RabbitMQ.
_ Publicação e escuta de eventos via MassTransit com injeção de dependência nativa.
_ Compatível com o padrão Transactional Outbox para maior confiabilidade.

Vantagens:
_ Alta escalabilidade com comunicação baseada em eventos.
_ Desacoplamento entre produtores e consumidores.
_ Maior tolerância a falhas e reprocessamento automático.
_ Facilidade de manutenção e extensão de fluxos de negócio assíncronos.

Foi implementado um mecanismo robusto de Unit of Work com controle total de transações, gerenciamento de eventos de domínio, publicação de eventos de integração (Outbox Pattern), rollback automático e suporte ao padrão Result para commit/rollback com base em sucesso ou falha da operação.

Destaques:
_ Criação explícita de transações com controle de nível de isolamento.
_ Publicação de Domain Events sincronizados à persistência dos dados.
_ Publicação de Integration Events de forma desacoplada via Outbox Pattern.
_ Rollback automático e tratamento de exceções com suporte a validações de constraints.
_ Commit condicionado ao Result da operação.
_ Log estruturado de eventos, transações e falhas.

Benefícios:
_ Consistência transacional entre gravações no banco e eventos gerados.
_ Flexibilidade para usar SaveChanges padrão ou controle total do fluxo.
_ Facilidade para testes unitários e rastreabilidade de falhas.
_ Separação clara entre Domínio e Infraestrutura, com suporte ao MediatR.

Agora é possível definir, individualmente para cada serviço gerado, o banco de dados a ser utilizado — com suporte nativo ao SQL Server e PostgreSQL.

Essa abordagem permite que cada serviço tenha seu banco exclusivo, garantindo isolamento total e facilitando práticas de arquitetura voltadas a microsserviços reais.

Nos casos de serviços modulares, a aplicação continua utilizando um único banco de dados por serviço, com separação de cada módulo por schema, preservando organização e coesão.

Principais benefícios:
_ Isolamento de dados entre serviços, aumentando a segurança e clareza de responsabilidades.
_ Possibilidade de adoção progressiva de microsserviços com bancos independentes.
_ Separação por schema em serviços modulares, facilitando manutenção e entendimento do domínio.
_ Flexibilidade total na escolha do SGBD mais adequado por serviço.
_ Facilidade para testes, deploys isolados e escalabilidade horizontal.

O Lino CLI agora permite que o desenvolvedor escolha, durante a geração do projeto, entre criar serviços simples (tradicionais) ou serviços modulares, com total liberdade para combinar ambos conforme a necessidade da solução.

Essa abordagem traz suporte direto a diferentes estilos arquiteturais:
Serviços simples: ideais para compor soluções baseadas em microsserviços ou para construir aplicações monolíticas tradicionais de maneira direta e isolada.
Serviços modulares: organizam o domínio da aplicação em Bounded Contexts, facilitando a adoção de um Monólito Modular com separação clara de responsabilidades e melhor coesão entre componentes.

Você pode adicionar quantos serviços quiser — simples, modulares ou ambos — conforme o cenário da aplicação.

Vantagens dessa abordagem:
_ Maior flexibilidade na modelagem da arquitetura.
_ Facilidade para escalar de um monólito para microsserviços de forma progressiva.
_ Separação clara de responsabilidades por domínio ou contexto.
_ Melhor organização do código e alinhamento com boas práticas de arquitetura moderna.
_ Redução de acoplamento e aumento da manutenibilidade.

Desenvolva com microsserviços ou adote um monólito modular — você escolhe o caminho ideal para sua aplicação.

Adicionado suporte nativo a cache híbrido utilizando a biblioteca Microsoft.Extensions.Caching.Hybrid.

A implementação combina cache em memória (MemoryCache) com cache distribuído (DistributedCache), oferecendo o melhor dos dois mundos.

Essa abordagem permite respostas extremamente rápidas para requisições frequentes, enquanto mantém sincronização e escalabilidade em ambientes distribuídos.

Benefícios da estratégia híbrida:
_ Alto desempenho com leitura imediata da memória local.
_ Persistência e compartilhamento de dados entre instâncias via cache distribuído.
_ Redução de chamadas ao banco de dados e APIs externas.
_ Melhor escalabilidade horizontal em aplicações com múltiplas réplicas.
_ Sincronização inteligente entre os dois níveis de cache.

Ideal para cenários que exigem performance e consistência sem abrir mão da flexibilidade arquitetural.

O Lino CLI agora gera projetos com suporte integrado a múltiplos idiomas, incluindo tradução automática para as seguintes culturas:
en, pt-BR, es, fr, it, de, ja, ko, zh-Hans e ru.

Os arquivos de recursos (resx) são gerados automaticamente com base no idioma principal, e os conteúdos são traduzidos automaticamente, prontos para uso imediato em aplicações globais.

Vantagens do suporte multilíngue:
_ Facilita a criação de aplicações voltadas a diferentes regiões e culturas.
_ Reduz o tempo necessário para internacionalização.
_ Integração nativa com o sistema de localização do .NET.
_ Melhora a experiência do usuário final em aplicações multilingues.
_ Permite escalar soluções para o mercado global com rapidez.

Os códigos gerados pelo Lino CLI agora utilizam da LoggerMessage para registrar logs de forma mais eficiente e com melhor desempenho.

Ao contrário dos métodos de extensão convencionais do ILogger, que geram boxing de tipos de valor e têm impacto de alocação em tempo de execução, o padrão LoggerMessage cria Actions fortemente tipadas e estáticas para cada mensagem de log.

Vantagens desta abordagem:
_ Redução significativa de alocações de memória.
_ Evita boxing de tipos de valor como int, Guid, DateTime, etc.
_ Melhor desempenho em cenários de alto volume de log.
_ Padronização e centralização das mensagens de log.
_ Mais clareza na auditoria, diagnóstico e monitoramento.

Essa melhoria é especialmente relevante em APIs e serviços de backend onde performance e rastreabilidade são fundamentais.

Lino CLI agora oferece suporte opcional a Strongly Typed Ids, permitindo que identificadores de entidades sejam representados por tipos específicos fortemente tipados ao invés de tipos genéricos como Guid ou int.

Esse recurso ajuda a evitar erros comuns como atribuir um identificador de uma entidade a outra incorretamente, além de deixar o código mais expressivo e alinhado ao domínio da aplicação.

Vantagens do uso de Strongly Typed Ids:
_ Maior segurança de tipo em tempo de compilação.
_ Evita atribuições acidentais entre entidades diferentes.
_ Melhora a legibilidade e clareza da intenção do código.
_ Facilita o rastreamento e debug de identificadores no domínio.
_ Integração com EF Core, JSON serialization e validation.

A ativação do recurso é opcional e pode ser definida no momento da geração do projeto.

Os projetos gerados agora podem ser configurados com suporte a análise estática de código, utilizando os principais analisadores do ecossistema .NET. Essas ferramentas são integradas diretamente ao build e ajudam a identificar problemas de formatação, estilo, arquitetura e possíveis falhas de lógica ainda em tempo de desenvolvimento.

Vantagens:
_ Promove consistência e padronização no código desde o início.
_ Detecta bugs e más práticas antecipadamente.
_ Facilita revisões de código e onboardings técnicos.
_ Melhora a qualidade e a manutenibilidade da base de código.
_ Evita erros comuns e melhora a aderência às boas práticas do .NET.

A configuração pode ser personalizada por projeto, permitindo maior flexibilidade no nível de rigor desejado.

Criação da biblioteca Tolitech.Results, que implementa o Result Pattern de forma completa e fluente no .NET.

Essa biblioteca encapsula o resultado de operações — sejam elas bem-sucedidas ou com falhas — em objetos estruturados, contendo status HTTP, mensagens, erros, títulos, detalhes e dados opcionais (com suporte a Result<T>).

Benefícios do uso do Result Pattern:
_ Padronização no retorno de operações em toda a aplicação.
_ Redução de exceções como controle de fluxo.
_ Facilidade na composição e encadeamento de operações.
_ Melhor suporte à comunicação entre camadas e serviços.
_ Integração fluida com HTTP APIs, validações e mensagens de erro.
_ Melhor experiência de depuração e log estruturado.

Além disso, extensões como Tolitech.Results.Http e Tolitech.Results.Guards ampliam a integração com APIs REST e validações defensivas.