• ✅ Separação por Domínios: Cada módulo representa um domínio funcional
• ✅ Independência Relativa: Módulos podem ser habilitados/desabilitados
• ✅ Feature Flags: Controle granular de funcionalidades por território
• ✅ Clean Architecture: Camadas bem definidas (Domain, Application, Infrastructure, API)
• ✅ Extensibilidade: Fácil adicionar novos módulos sem impactar existentes

Isolamento real (deploy, rede, falhas independentes) só existe com serviços separados (microserviços). Para o tamanho e estágio do projeto, o Arah não adota microserviços.

O objetivo adotado é ter infraestrutura independente por módulo, isolando pontos de manutenção e de falha dentro do mesmo processo:

• Manutenção: alterações em Feed (schema, repositório, bugs) ficam contidas no projeto Arah.Modules.Feed.Infrastructure; o mesmo para Events, Map, Chat, Marketplace, etc. Menos risco de regressão em outros domínios e ownership claro por módulo.
• Falha: um bug ou problema de persistência em um módulo fica limitado ao código e ao DbContext daquele módulo; o restante da aplicação continua referenciando apenas interfaces da Application.
• Evolução: se no futuro um módulo precisar virar serviço separado, a fronteira já está desenhada (projeto de infra + contratos de aplicação).

Ou seja: uma infraestrutura modular, não vários serviços, com isolamento de responsabilidade e de impacto por domínio.

---

Cada módulo segue Clean Architecture com camadas:

Módulo/
├── Domain/           # Entidades, Value Objects, Interfaces
├── Application/     # Services, Use Cases, DTOs
├── Infrastructure/   # Repositories, External Services
└── Api/             # Controllers, Endpoints

Arah.Api (API Layer)
    ↓
Arah.Application (Application Layer)
    ├── Módulo 1 (Domain Services)
    ├── Módulo 2 (Domain Services)
    └── Módulo N (Domain Services)
    ↓
Arah.Domain (Domain Layer)
    ├── Módulo 1 (Entities, Value Objects)
    ├── Módulo 2 (Entities, Value Objects)
    └── Módulo N (Entities, Value Objects)
    ↓
Arah.Infrastructure (Infrastructure Layer)
    ├── Módulo 1 (Repositories, External Services)
    ├── Módulo 2 (Repositories, External Services)
    └── Módulo N (Repositories, External Services)

backend/
├── Arah.Api/
│   ├── Controllers/
│   │   ├── AuthController.cs          # Módulo: Autenticação
│   │   ├── TerritoriesController.cs   # Módulo: Territórios
│   │   ├── FeedController.cs          # Módulo: Feed
│   │   ├── EventsController.cs        # Módulo: Eventos
│   │   ├── MarketplaceController.cs  # Módulo: Marketplace
│   │   └── ChatController.cs          # Módulo: Chat
│   └── ...
├── Arah.Application/
│   ├── Services/
│   │   ├── Auth/                      # Módulo: Autenticação
│   │   ├── Territories/               # Módulo: Territórios
│   │   ├── Feed/                      # Módulo: Feed
│   │   ├── Events/                    # Módulo: Eventos
│   │   ├── Marketplace/               # Módulo: Marketplace
│   │   └── Chat/                      # Módulo: Chat
│   └── ...
├── Arah.Domain/
│   ├── Users/                         # Módulo: Autenticação
│   ├── Territories/                   # Módulo: Territórios
│   ├── Feed/                          # Módulo: Feed
│   ├── Events/                        # Módulo: Eventos
│   ├── Marketplace/                   # Módulo: Marketplace
│   └── Chat/                          # Módulo: Chat
└── Arah.Infrastructure/
    ├── Postgres/
    │   ├── Entities/                  # Mapeamento por módulo
    │   └── Repositories/              # Repositories por módulo
    └── ...

---

• Responsabilidade: Publicações e timeline territorial
• Elementos: Post, PostGeoAnchor, Media
• Feature Flags:
  • AlertPosts - Permitir posts do tipo ALERT
  • EventPosts - Permitir posts de eventos
  • MediaImagesEnabled - Habilitar imagens
  • MediaVideosEnabled - Habilitar vídeos
  • MediaAudioEnabled - Habilitar áudios

• Responsabilidade: Organizar eventos comunitários por território
• Elementos: Event, participação, georreferenciamento
• Feature Flags:
  • EventPosts - Habilitar eventos no feed
  • MediaImagesEnabled - Habilitar imagens em eventos
  • MediaVideosEnabled - Habilitar vídeos em eventos
  • MediaAudioEnabled - Habilitar áudios em eventos

• Responsabilidade: Comunicação territorial (canais, grupos, DM)
• Elementos: ChatConversation, ChatMessage, ConversationParticipant
• Feature Flags:
  • ChatEnabled - Master switch do chat
  • ChatTerritoryPublicChannel - Canal público
  • ChatTerritoryResidentsChannel - Canal de moradores
  • ChatGroups - Grupos no chat
  • ChatDmEnabled - Mensagens diretas
  • ChatMediaEnabled - Mídias no chat
  • ChatMediaImagesEnabled - Imagens no chat
  • ChatMediaAudioEnabled - Áudios no chat

• Responsabilidade: Sistema de trocas locais integrado ao território
• Elementos: Store, StoreItem, Cart, Checkout
• Feature Flags:
  • MarketplaceEnabled - Habilitar marketplace
  • MediaImagesEnabled - Habilitar imagens em itens
  • MediaVideosEnabled - Habilitar vídeos em itens
  • MediaAudioEnabled - Habilitar áudios em itens

• Responsabilidade: Conexões entre usuários (círculo de amigos), priorização no feed e notificações de solicitação/aceitação
• Elementos: UserConnection, ConnectionPrivacySettings, ConnectionStatus, ConnectionRequestPolicy, ConnectionVisibility
• Feature Flags:
  • ConnectionsEnabled (15) — habilitar conexões no território
  • ConnectionsFeedPrioritize (16) — priorizar posts de conexões no feed

---

Cada módulo representa um domínio funcional completo:

1. Domínio = Módulo: Um domínio funcional = um módulo
2. Responsabilidade Única: Cada módulo tem uma responsabilidade clara
3. Independência Relativa: Módulos podem funcionar independentemente (com dependências explícitas)
4. Feature Flags: Controle granular de funcionalidades

Domínio Funcional	Módulo	Status
Autenticação e Identidade	Auth	Core
Territórios	Territories	Core
Memberships	Memberships	Core
Feed Comunitário	Feed	Opcional
Eventos	Events	Opcional
Mapa Territorial	Map	Opcional
Marketplace	Marketplace	Opcional
Chat	Chat	Opcional
Alertas	Alerts	Opcional
Assets	Assets	Opcional
Moderação	Moderation	Opcional
Notificações	Notifications	Opcional
Subscriptions	Subscriptions	Opcional
Governança	Governance	Opcional
Admin	Admin	Opcional
Conexões (Círculo de Amigos)	Connections	Opcional

---

public enum FeatureFlag
{
    // Feed
    AlertPosts = 1,
    EventPosts = 2,
    
    // Marketplace
    MarketplaceEnabled = 3,
    
    // Chat
    ChatEnabled = 4,
    ChatTerritoryPublicChannel = 5,
    ChatTerritoryResidentsChannel = 6,
    ChatGroups = 7,
    ChatDmEnabled = 8,
    ChatMediaEnabled = 9,
    
    // Mídias
    MediaImagesEnabled = 10,
    MediaVideosEnabled = 11,
    MediaAudioEnabled = 12,
    ChatMediaImagesEnabled = 13,
    ChatMediaAudioEnabled = 14,
    // Conexões (Círculo de Amigos)
    ConnectionsEnabled = 15,
    ConnectionsFeedPrioritize = 16
}

Módulo	Depende de	Tipo
Feed	Territórios, Memberships	Obrigatória
Eventos	Territórios, Memberships	Obrigatória
Mapa	Territórios, Feed/Eventos	Obrigatória
Marketplace	Territórios, Memberships	Obrigatória
Chat	Territórios, Memberships, Notificações	Obrigatória
Alertas	Territórios, Feed	Obrigatória
Assets	Territórios, Memberships	Obrigatória
Moderação	Territórios, Memberships	Obrigatória
Governança	Territórios, Memberships	Obrigatória
Notificações	Autenticação	Obrigatória
Subscriptions	Autenticação, Territórios	Obrigatória
Admin	Autenticação	Obrigatória
Connections (Círculo de Amigos)	Autenticação, Memberships, Notificações	Obrigatória

O sistema valida dependências na inicialização:

public void ValidateModuleDependencies(
    IEnumerable<string> enabledModules)
{
    var requiredModules = new Dictionary<string, string[]>
    {
        { "Chat", new[] { "Territories", "Memberships", "Notifications" } },
        { "Marketplace", new[] { "Territories", "Memberships" } },
        // ...
    };
    
    foreach (var module in enabledModules)
    {
        if (requiredModules.TryGetValue(module, out var deps))
        {
            foreach (var dep in deps)
            {
                if (!enabledModules.Contains(dep))
                {
                    throw new InvalidOperationException(
                        $"{module} requires {dep}");
                }
            }
        }
    }
}

---

1. Criar Estrutura de Diretórios:

   backend/
   ├── Arah.Domain/NewModule/
   ├── Arah.Application/Services/NewModule/
   ├── Arah.Infrastructure/Postgres/Entities/NewModule/
   └── Arah.Api/Controllers/NewModuleController.cs
   

2. Definir Feature Flags (se necessário):

   public enum FeatureFlag
   {
       // ... flags existentes
       NewModuleEnabled = 15
   }
   

3. Registrar no DI Container:

   services.AddScoped<INewModuleService, NewModuleService>();
   

4. Adicionar ao Instalador:

   • Adicionar módulo à lista de seleção
   • Configurar feature flags relacionadas
   • Adicionar validações de dependências