A criação de features em projetos Flutter cresce naturalmente em complexidade. Arquiteturas modulares exigem consistência: definir entidades, contratos, infraestruturas, módulos de injeção e páginas repetidamente pode consumir tempo e gerar inconsistências entre desenvolvedores.

Para resolver isso, construí um brick para o Mason que gera toda a estrutura necessária com um único comando, trazendo organização, agilidade e previsibilidade para equipes de qualquer tamanho.

Este guia premium explica como instalar, usar e compreender cada arquivo gerado, com um visual moderno ideal para publicação.

O que esse brick resolve?

Ele transforma um processo repetitivo e suscetível a erro em uma automação elegante, padronizada e escalável.

mason make flutter_getit_feature_brick name=products

Você ganha uma feature completa com:

• Módulo pronto do flutter_getit
• Camada domain
• Camada Infrastructure
• Camada Presenation
• Entidades, Repositórios, Serviços e Usecases
• Modelos concretos
• Injeção de todas as dependências já prontas

Instalando o Mason

Primeiro você precisa ativar o Mason no seu flutter com o comando abaixo

dart pub global activate mason_cli

Depois iniciar dentro do seu projeto com

mason init

Registra o seu brick no yaml que ele vai gerar

bricks:  
    flutter_getit_feature_brick:
      path: ./bricks/flutter_getit_feature_brick

Depois disso so precisa rodar

mason get

Assim quando for gear uma nova feature com o comando abaixo o resultado sera em lib/src/features/login

mason make flutter_getit_feature_brick name=login

Visão geral da arquitetura gerada

Essa divisão facilita testes, expansões, manutenção e substituição de dependências em qualquer momento.

lib/
└── src/
    └── features/
        └── {{name}}/
            ├── {{name}}_module.dart
            ├── presentation/
            │   └── pages/
            │       └── {{name}}_page.dart
            ├── domain/
            │   ├── entities/
            │   │   └── {{name}}.dart
            │   ├── repositories/
            │   │   └── {{name}}_repository.dart
            │   ├── services/
            │   │   └── {{name}}_service.dart
            │   └── usecases/
            │       └── {{name}}_usecase.dart
            └── infrastructure/
                ├── models/
                │   └── {{name}}_model.dart
                ├── repositories/
                │   └── {{name}}_repository_impl.dart
                └── services/
                    └── {{name}}_service.dart

Explicação visual arquivo por arquivo

A seguir você verá uma explicação premium, clara e visual de cada parte gerada.

1. {{name}}_module.dart — O Centro de Injeção de Dependências

2. Presentation Layer — Interface com o Usuário

Arquivo: presentation/pages/{{name}}_page.dart

Este arquivo é o ponto onde fluxo visual de cada feature começa.

3. Domain Layer — A Regra de Negócio

A camada Domain é pura, testável e não depende de infraestrutura.

3.1 Entidade — domain/entities/{{name}}.dart

Representa o modelo central da feature.

3.2 Repositório — domain/repositories/{{name}}_repository.dart

Define o que deve ser feito, não como.

3.3 Serviço de domínio — domain/services/{{name}}_service.dart

Ideal para lógica complexa que não pertence diretamente ao caso de uso ou entidade.

3.4 Caso de Uso — domain/usecases/{{name}}_usecase.dart

A peça central da regra de negócio.

4. Infrastructure Layer — Implementação Concreta

A camada Infrastructure conecta o domínio ao “mundo real”.

4.1 Model — infrastructure/models/{{name}}_model.dart

Conversão entre API e entidades internas.

4.2 Repository Impl — infrastructure/repositories/{{name}}_repository_impl.dart

Aqui está o “como”.

4.3 Serviço externo — infrastructure/services/{{name}}_service.dart

Realiza operações externas reais como:

• requisições HTTP
• consultas locais
• integrações

Quando você gera uma feature, o Mason cria uma pasta completa dentro de lib/src/features. Dentro dela vivem três grandes camadas: Presentation, Domain e Infrastructure. O módulo da feature conecta tudo via GetIt. A Presentation mostra para o usuário. O Domain decide como as coisas funcionam. A Infrastructure conversa com o mundo externo.