@polymorphism-tech/morph-spec 1.0.0

package/content/.claude/skills/stacks/dotnet-blazor.md

@@ -0,0 +1,352 @@
+# .NET + Blazor Stack
+
+Stack principal para desenvolvimento de aplicações web com .NET e Blazor Server.
+
+## Visão Geral
+
+| Aspecto | Tecnologia |
+|---------|------------|
+| **Backend** | .NET 9+ / C# 13+ |
+| **Frontend** | Blazor Server |
+| **Database** | Entity Framework Core 9 + Azure SQL |
+| **Hosting** | Azure Container Apps |
+| **Background** | Hangfire |
+| **AI** | Microsoft Agent Framework |
+
+## Triggers
+
+Keywords: `blazor`, `razor`, `server-side`, `.net`, `csharp`, `dotnet`
+
+## Estrutura de Projeto
+
+```
+src/
+├── {App}.Domain/                  # Entidades, Value Objects, Enums
+│   ├── Entities/
+│   ├── ValueObjects/
+│   ├── Enums/
+│   └── Exceptions/
+│
+├── {App}.Application/             # Serviços, DTOs, Interfaces
+│   ├── Services/
+│   ├── DTOs/
+│   ├── Interfaces/
+│   └── Validators/
+│
+├── {App}.Infrastructure/          # EF Core, External Services
+│   ├── Data/
+│   │   ├── AppDbContext.cs
+│   │   ├── Configurations/
+│   │   └── Migrations/
+│   ├── Services/
+│   └── Extensions/
+│
+├── {App}.Web/                     # Blazor Server
+│   ├── Program.cs
+│   ├── Components/
+│   │   ├── Layout/
+│   │   ├── Pages/
+│   │   └── Shared/
+│   ├── wwwroot/
+│   └── appsettings.json
+│
+└── tests/
+    ├── {App}.UnitTests/
+    └── {App}.IntegrationTests/
+```
+
+## Configuração do Projeto
+
+### csproj principal
+
+```xml
+<!-- {App}.Web.csproj -->
+<Project Sdk="Microsoft.NET.Sdk.Web">
+  <PropertyGroup>
+    <TargetFramework>net9.0</TargetFramework>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\{App}.Application\{App}.Application.csproj" />
+    <ProjectReference Include="..\{App}.Infrastructure\{App}.Infrastructure.csproj" />
+  </ItemGroup>
+</Project>
+```
+
+### Program.cs
+
+```csharp
+var builder = WebApplication.CreateBuilder(args);
+
+// Services
+builder.Services.AddRazorComponents()
+    .AddInteractiveServerComponents();
+
+// Database
+builder.Services.AddDbContext<AppDbContext>(options =>
+    options.UseSqlServer(builder.Configuration.GetConnectionString("DefaultConnection")));
+
+// Application Services
+builder.Services.AddScoped<IOrderService, OrderService>();
+builder.Services.AddScoped<ICustomerService, CustomerService>();
+
+// Hangfire
+builder.Services.AddHangfire(config => config
+    .UseSqlServerStorage(builder.Configuration.GetConnectionString("HangfireConnection")));
+builder.Services.AddHangfireServer();
+
+var app = builder.Build();
+
+// Pipeline
+if (!app.Environment.IsDevelopment())
+{
+    app.UseExceptionHandler("/Error");
+    app.UseHsts();
+}
+
+app.UseHttpsRedirection();
+app.UseStaticFiles();
+app.UseAntiforgery();
+
+app.MapRazorComponents<App>()
+    .AddInteractiveServerRenderMode();
+
+app.MapHangfireDashboard("/hangfire");
+
+app.Run();
+```
+
+## Componentes Blazor
+
+### Padrões de Componente
+
+```razor
+@* Components/Pages/Orders/OrderList.razor *@
+@page "/orders"
+@inject IOrderService OrderService
+@inject NavigationManager Navigation
+
+<PageTitle>Pedidos</PageTitle>
+
+<div class="container mx-auto p-4">
+    <div class="flex justify-between items-center mb-6">
+        <h1 class="text-2xl font-bold">Pedidos</h1>
+        <button @onclick="CreateNew" class="btn btn-primary">
+            Novo Pedido
+        </button>
+    </div>
+
+    @if (_orders is null)
+    {
+        <Loading />
+    }
+    else if (!_orders.Any())
+    {
+        <EmptyState Message="Nenhum pedido encontrado" />
+    }
+    else
+    {
+        <DataTable Items="_orders">
+            <HeaderTemplate>
+                <th>Número</th>
+                <th>Cliente</th>
+                <th>Total</th>
+                <th>Status</th>
+                <th>Ações</th>
+            </HeaderTemplate>
+            <RowTemplate Context="order">
+                <td>@order.OrderNumber</td>
+                <td>@order.CustomerName</td>
+                <td>@order.Total.ToString("C")</td>
+                <td><StatusBadge Status="@order.Status" /></td>
+                <td>
+                    <button @onclick="() => ViewOrder(order.Id)" class="btn btn-sm">
+                        Ver
+                    </button>
+                </td>
+            </RowTemplate>
+        </DataTable>
+    }
+</div>
+
+@code {
+    private List<OrderDto>? _orders;
+
+    protected override async Task OnInitializedAsync()
+    {
+        _orders = await OrderService.GetAllAsync();
+    }
+
+    private void CreateNew() => Navigation.NavigateTo("/orders/new");
+
+    private void ViewOrder(int id) => Navigation.NavigateTo($"/orders/{id}");
+}
+```
+
+### Formulários
+
+```razor
+@* Components/Pages/Orders/OrderForm.razor *@
+@page "/orders/new"
+@page "/orders/{Id:int}/edit"
+@inject IOrderService OrderService
+@inject NavigationManager Navigation
+
+<PageTitle>@(_isEdit ? "Editar" : "Novo") Pedido</PageTitle>
+
+<EditForm Model="_model" OnValidSubmit="HandleSubmit">
+    <DataAnnotationsValidator />
+
+    <div class="space-y-4">
+        <div>
+            <label for="customerId">Cliente</label>
+            <InputSelect @bind-Value="_model.CustomerId" id="customerId" class="input">
+                <option value="">Selecione...</option>
+                @foreach (var customer in _customers)
+                {
+                    <option value="@customer.Id">@customer.Name</option>
+                }
+            </InputSelect>
+            <ValidationMessage For="() => _model.CustomerId" />
+        </div>
+
+        <div>
+            <label for="notes">Observações</label>
+            <InputTextArea @bind-Value="_model.Notes" id="notes" class="input" />
+        </div>
+
+        <div class="flex gap-2">
+            <button type="submit" class="btn btn-primary" disabled="@_isSubmitting">
+                @if (_isSubmitting)
+                {
+                    <span class="loading"></span>
+                }
+                Salvar
+            </button>
+            <button type="button" @onclick="Cancel" class="btn">Cancelar</button>
+        </div>
+    </div>
+</EditForm>
+
+@code {
+    [Parameter] public int? Id { get; set; }
+
+    private OrderFormModel _model = new();
+    private List<CustomerDto> _customers = new();
+    private bool _isEdit => Id.HasValue;
+    private bool _isSubmitting;
+
+    protected override async Task OnInitializedAsync()
+    {
+        _customers = await CustomerService.GetAllAsync();
+
+        if (_isEdit)
+        {
+            var order = await OrderService.GetByIdAsync(Id!.Value);
+            _model = new OrderFormModel
+            {
+                CustomerId = order.CustomerId,
+                Notes = order.Notes
+            };
+        }
+    }
+
+    private async Task HandleSubmit()
+    {
+        _isSubmitting = true;
+
+        try
+        {
+            if (_isEdit)
+                await OrderService.UpdateAsync(Id!.Value, _model);
+            else
+                await OrderService.CreateAsync(_model);
+
+            Navigation.NavigateTo("/orders");
+        }
+        finally
+        {
+            _isSubmitting = false;
+        }
+    }
+
+    private void Cancel() => Navigation.NavigateTo("/orders");
+}
+```
+
+## Services
+
+```csharp
+// Application/Services/OrderService.cs
+public interface IOrderService
+{
+    Task<List<OrderDto>> GetAllAsync(CancellationToken ct = default);
+    Task<OrderDto> GetByIdAsync(int id, CancellationToken ct = default);
+    Task<OrderDto> CreateAsync(CreateOrderRequest request, CancellationToken ct = default);
+    Task UpdateAsync(int id, UpdateOrderRequest request, CancellationToken ct = default);
+}
+
+public class OrderService : IOrderService
+{
+    private readonly AppDbContext _context;
+    private readonly ILogger<OrderService> _logger;
+
+    public OrderService(AppDbContext context, ILogger<OrderService> logger)
+    {
+        _context = context;
+        _logger = logger;
+    }
+
+    public async Task<List<OrderDto>> GetAllAsync(CancellationToken ct = default)
+    {
+        return await _context.Orders
+            .Include(o => o.Customer)
+            .OrderByDescending(o => o.CreatedAt)
+            .Select(o => new OrderDto
+            {
+                Id = o.Id,
+                OrderNumber = o.OrderNumber,
+                CustomerName = o.Customer.Name,
+                Total = o.Total,
+                Status = o.Status.ToString()
+            })
+            .ToListAsync(ct);
+    }
+
+    public async Task<OrderDto> CreateAsync(CreateOrderRequest request, CancellationToken ct = default)
+    {
+        var order = Order.Create(request.CustomerId, request.Items);
+
+        _context.Orders.Add(order);
+        await _context.SaveChangesAsync(ct);
+
+        _logger.LogInformation("Order {OrderNumber} created", order.OrderNumber);
+
+        return new OrderDto { /* map */ };
+    }
+}
+```
+
+## Documentação de Referência
+
+- [Blazor Documentation](https://learn.microsoft.com/en-us/aspnet/core/blazor/)
+- [Entity Framework Core](https://learn.microsoft.com/en-us/ef/core/)
+- [ASP.NET Core](https://learn.microsoft.com/en-us/aspnet/core/)
+- [Hangfire](https://docs.hangfire.io/)
+
+## Checklist de Projeto
+
+- [ ] Estrutura de camadas (Domain, Application, Infrastructure, Web)
+- [ ] EF Core configurado com migrations
+- [ ] Blazor Server com componentes reutilizáveis
+- [ ] Services com injeção de dependência
+- [ ] Logging estruturado
+- [ ] Validação com FluentValidation ou DataAnnotations
+- [ ] Hangfire para background jobs
+- [ ] Dockerfile para containerização
+
+---
+
+*MORPH-SPEC by Polymorphism Tech*