@atlashub/smartstack-cli 4.32.0 → 4.34.0

package/templates/project/claude-md/application.CLAUDE.md.template

@@ -0,0 +1,181 @@
+# {{ProjectName}}.Application - Memory
+
+## Purpose
+
+Use cases orchestration. Defines WHAT the application does. Contains business logic that doesn't belong to entities.
+
+## Dependencies
+
+- **{{ProjectName}}.Domain** (entities, interfaces)
+- **MediatR** (CQRS) - add when needed
+- **FluentValidation** - add when needed
+- **AutoMapper** - add when needed
+
+## Structure
+
+```
+{{ProjectName}}.Application/
+├── Common/
+│   ├── Authorization/             → Permissions constants
+│   ├── Behaviors/                 → MediatR pipeline behaviors
+│   ├── Exceptions/                → Application exceptions
+│   ├── Interfaces/
+│   │   ├── Identity/              → ICurrentUserService, IJwtService
+│   │   └── Persistence/           → IExtensionsDbContext
+│   └── Licensing/                 → License validation
+├── {Feature}/                     → Feature-specific commands/queries
+│   ├── Commands/
+│   ├── Queries/
+│   └── DTOs/
+└── DependencyInjection.cs
+```
+
+## Patterns
+
+### Command Template (with MediatR)
+
+```csharp
+namespace {{ProjectName}}.Application.{Feature}.Commands;
+
+// Command
+public record CreateOrderCommand(string Name, decimal Amount) : IRequest<Guid>;
+
+// Handler
+public class CreateOrderCommandHandler : IRequestHandler<CreateOrderCommand, Guid>
+{
+    private readonly IExtensionsDbContext _context;
+
+    public CreateOrderCommandHandler(IExtensionsDbContext context)
+    {
+        _context = context;
+    }
+
+    public async Task<Guid> Handle(CreateOrderCommand request, CancellationToken ct)
+    {
+        var order = Order.Create(request.Name, request.Amount);
+
+        await _context.Orders.AddAsync(order, ct);
+        await _context.SaveChangesAsync(ct);
+
+        return order.Id;
+    }
+}
+
+// Validator (FluentValidation)
+public class CreateOrderCommandValidator : AbstractValidator<CreateOrderCommand>
+{
+    public CreateOrderCommandValidator()
+    {
+        RuleFor(x => x.Name)
+            .NotEmpty().WithMessage("Name is required")
+            .MaximumLength(200).WithMessage("Name max 200 chars");
+
+        RuleFor(x => x.Amount)
+            .GreaterThan(0).WithMessage("Amount must be positive");
+    }
+}
+```
+
+### Query Template
+
+```csharp
+namespace {{ProjectName}}.Application.{Feature}.Queries;
+
+// Query
+public record GetOrdersQuery(string? SearchTerm = null) : IRequest<IReadOnlyList<OrderDto>>;
+
+// Handler
+public class GetOrdersQueryHandler : IRequestHandler<GetOrdersQuery, IReadOnlyList<OrderDto>>
+{
+    private readonly IExtensionsDbContext _context;
+    private readonly IMapper _mapper;
+
+    public GetOrdersQueryHandler(IExtensionsDbContext context, IMapper mapper)
+    {
+        _context = context;
+        _mapper = mapper;
+    }
+
+    public async Task<IReadOnlyList<OrderDto>> Handle(GetOrdersQuery request, CancellationToken ct)
+    {
+        var query = _context.Orders.AsNoTracking();
+
+        if (!string.IsNullOrWhiteSpace(request.SearchTerm))
+            query = query.Where(o => o.Name.Contains(request.SearchTerm));
+
+        return await query
+            .ProjectTo<OrderDto>(_mapper.ConfigurationProvider)
+            .ToListAsync(ct);
+    }
+}
+```
+
+### DTO Template
+
+```csharp
+namespace {{ProjectName}}.Application.{Feature}.DTOs;
+
+public record OrderDto(Guid Id, string Name, decimal Amount, DateTime CreatedAt);
+
+// AutoMapper Profile
+public class OrderProfile : Profile
+{
+    public OrderProfile()
+    {
+        CreateMap<Order, OrderDto>();
+    }
+}
+```
+
+### Interface Template (ExtensionsDbContext)
+
+```csharp
+namespace {{ProjectName}}.Application.Common.Interfaces.Persistence;
+
+public interface IExtensionsDbContext
+{
+    DbSet<Order> Orders { get; }
+    // Add DbSets for your entities here
+    Task<int> SaveChangesAsync(CancellationToken ct = default);
+}
+```
+
+## DependencyInjection Setup
+
+```csharp
+public static class DependencyInjection
+{
+    public static IServiceCollection AddApplication(this IServiceCollection services)
+    {
+        var assembly = typeof(DependencyInjection).Assembly;
+
+        services.AddMediatR(cfg => cfg.RegisterServicesFromAssembly(assembly));
+        services.AddValidatorsFromAssembly(assembly);
+        services.AddAutoMapper(assembly);
+        services.AddTransient(typeof(IPipelineBehavior<,>), typeof(ValidationBehavior<,>));
+        services.AddTransient(typeof(IPipelineBehavior<,>), typeof(LoggingBehavior<,>));
+
+        return services;
+    }
+}
+```
+
+## Rules
+
+1. **NO** direct database access - use `IExtensionsDbContext` (from Common/Interfaces/Persistence)
+2. **NO** HttpContext, Controllers - that's API layer
+3. **Commands** modify state, return Id or nothing
+4. **Queries** read-only, return DTOs
+5. **Handlers** are the use cases
+6. **One handler per command/query**
+
+## When Adding New Feature
+
+1. Create folder in `{Feature}/` (appropriate namespace path)
+2. Add `Commands/` and/or `Queries/` subfolders
+3. Add `DTOs/` subfolder if needed
+4. Create Command/Query record
+5. Create Handler class
+6. Create Validator (optional but recommended)
+7. Add DTO record and AutoMapper profile if needed
+8. Register in `DependencyInjection.cs`

package/templates/project/claude-md/domain.CLAUDE.md.template

@@ -0,0 +1,125 @@
+# {{ProjectName}}.Domain - Memory
+
+## Purpose
+
+Core business logic. **ZERO external dependencies**. This layer defines WHAT the business does, not HOW.
+
+## Structure
+
+```
+{{ProjectName}}.Domain/
+├── Common/
+│   ├── BaseEntity.cs              → Base for all entities (Id, CreatedAt, UpdatedAt)
+│   └── IAuditableEntity.cs        → Audit tracking interface
+├── Enums/                         → Domain enumerations
+├── {Feature}/                     → Feature-specific entities
+│   ├── Order.cs                   → Aggregate root
+│   └── OrderItem.cs               → Child entity
+├── Exceptions/                    → DomainException, custom exceptions
+└── Interfaces/                    → Repository contracts
+```
+
+## Rules (STRICT)
+
+1. **NO** NuGet packages except BCL
+2. **NO** `using` statements referencing other projects
+3. **NO** EF Core attributes (`[Key]`, `[Required]`) - use Fluent API in Infrastructure
+4. **NO** DTOs - entities only
+5. **ALL** business rules live here
+
+## Patterns
+
+### Entity Template
+
+```csharp
+namespace {{ProjectName}}.Domain.{Feature};
+
+public class Order : BaseEntity
+{
+    public string Name { get; private set; } = null!;
+    public decimal Amount { get; private set; }
+    public bool IsActive { get; private set; }
+
+    private Order() { } // EF Core
+
+    public static Order Create(string name, decimal amount)
+    {
+        if (string.IsNullOrWhiteSpace(name))
+            throw new DomainException("Name is required");
+        if (amount <= 0)
+            throw new DomainException("Amount must be positive");
+
+        return new Order
+        {
+            Id = Guid.NewGuid(),
+            Name = name,
+            Amount = amount,
+            IsActive = true,
+            CreatedAt = DateTime.UtcNow
+        };
+    }
+
+    public void Deactivate()
+    {
+        IsActive = false;
+        UpdatedAt = DateTime.UtcNow;
+    }
+}
+```
+
+### Value Object Template
+
+```csharp
+namespace {{ProjectName}}.Domain.Common.ValueObjects;
+
+public record Money(decimal Amount, string Currency)
+{
+    public static Money Create(decimal amount, string currency)
+    {
+        if (amount < 0)
+            throw new DomainException("Amount cannot be negative");
+        if (string.IsNullOrWhiteSpace(currency))
+            throw new DomainException("Currency is required");
+
+        return new Money(amount, currency);
+    }
+}
+```
+
+### Domain Event Template
+
+```csharp
+namespace {{ProjectName}}.Domain.Common.Events;
+
+public record OrderCreatedEvent(Guid OrderId, string Name, DateTime OccurredAt);
+```
+
+### Repository Interface Template
+
+```csharp
+namespace {{ProjectName}}.Domain.Interfaces;
+
+public interface IRepository<T> where T : BaseEntity
+{
+    Task<T?> GetByIdAsync(Guid id, CancellationToken ct = default);
+    Task<IReadOnlyList<T>> GetAllAsync(CancellationToken ct = default);
+    Task AddAsync(T entity, CancellationToken ct = default);
+    void Update(T entity);
+    void Remove(T entity);
+}
+```
+
+## Validation
+
+- **Entities validate themselves** in constructors and methods
+- Throw `DomainException` for business rule violations
+- Use **Guard clauses** at method start
+
+## When Adding New Entity
+
+1. Create in the appropriate domain folder
+2. Inherit from `BaseEntity`
+3. Private parameterless constructor for EF
+4. Static `Create()` factory method
+5. Encapsulate all state changes in methods
+6. Add repository interface in `Interfaces/`

package/templates/project/claude-md/infrastructure.CLAUDE.md.template

@@ -0,0 +1,168 @@
+# {{ProjectName}}.Infrastructure - Memory
+
+## Purpose
+
+Technical implementations. HOW things work. EF Core, external APIs, file system, email, etc.
+
+## Dependencies
+
+- **{{ProjectName}}.Domain** (entities, repository interfaces)
+- **{{ProjectName}}.Application** (IExtensionsDbContext, service interfaces)
+- **Microsoft.EntityFrameworkCore.SqlServer**
+- **Microsoft.EntityFrameworkCore.Design**
+
+## Structure
+
+```
+{{ProjectName}}.Infrastructure/
+├── Persistence/
+│   ├── ExtensionsDbContext.cs          → EF Core DbContext (implements IExtensionsDbContext)
+│   ├── Configurations/                 → Entity configurations (Fluent API)
+│   │   ├── {Feature}/                  → Feature-specific configs
+│   │   └── SchemaConstants.cs          → Extensions="extensions"
+│   ├── Migrations/                     → EF Core migrations
+│   └── Seeding/                        → Database seeders
+├── Services/                           → Service implementations
+└── DependencyInjection.cs
+```
+
+## Patterns
+
+### DbContext Template
+
+```csharp
+namespace {{ProjectName}}.Infrastructure.Persistence;
+
+public class ExtensionsDbContext : DbContext, IExtensionsDbContext
+{
+    public ExtensionsDbContext(DbContextOptions<ExtensionsDbContext> options)
+        : base(options) { }
+
+    public DbSet<Order> Orders => Set<Order>();
+
+    protected override void OnModelCreating(ModelBuilder modelBuilder)
+    {
+        base.OnModelCreating(modelBuilder);
+        modelBuilder.HasDefaultSchema(SchemaConstants.Extensions);
+        modelBuilder.ApplyConfigurationsFromAssembly(typeof(ExtensionsDbContext).Assembly);
+    }
+
+    public override async Task<int> SaveChangesAsync(CancellationToken ct = default)
+    {
+        return await base.SaveChangesAsync(ct);
+    }
+}
+```
+
+### Entity Configuration Template
+
+```csharp
+namespace {{ProjectName}}.Infrastructure.Persistence.Configurations.{Feature};
+
+public class OrderConfiguration : IEntityTypeConfiguration<Order>
+{
+    public void Configure(EntityTypeBuilder<Order> builder)
+    {
+        builder.ToTable("ext_Orders", SchemaConstants.Extensions);
+
+        builder.HasKey(o => o.Id);
+
+        builder.Property(o => o.Name)
+            .IsRequired()
+            .HasMaxLength(200);
+
+        builder.Property(o => o.Amount)
+            .HasPrecision(18, 2);
+
+        builder.HasIndex(o => o.Name);
+    }
+}
+```
+
+### Repository Implementation Template
+
+```csharp
+namespace {{ProjectName}}.Infrastructure.Persistence.Repositories;
+
+public class OrderRepository : IOrderRepository
+{
+    private readonly ExtensionsDbContext _context;
+
+    public OrderRepository(ExtensionsDbContext context)
+    {
+        _context = context;
+    }
+
+    public async Task<Order?> GetByIdAsync(Guid id, CancellationToken ct = default)
+        => await _context.Orders.FindAsync(new object[] { id }, ct);
+
+    public async Task<IReadOnlyList<Order>> GetAllAsync(CancellationToken ct = default)
+        => await _context.Orders.ToListAsync(ct);
+
+    public async Task AddAsync(Order entity, CancellationToken ct = default)
+        => await _context.Orders.AddAsync(entity, ct);
+
+    public void Update(Order entity)
+        => _context.Orders.Update(entity);
+
+    public void Remove(Order entity)
+        => _context.Orders.Remove(entity);
+}
+```
+
+## DependencyInjection
+
+```csharp
+public static class DependencyInjection
+{
+    public static IServiceCollection AddInfrastructure(
+        this IServiceCollection services,
+        IConfiguration configuration)
+    {
+        services.AddDbContext<ExtensionsDbContext>(options =>
+            options.UseSqlServer(
+                configuration.GetConnectionString("DefaultConnection"),
+                b => b.MigrationsAssembly(typeof(ExtensionsDbContext).Assembly.FullName)));
+
+        services.AddScoped<IExtensionsDbContext>(provider =>
+            provider.GetRequiredService<ExtensionsDbContext>());
+
+        return services;
+    }
+}
+```
+
+## EF Core Commands
+
+```bash
+# Create migration (ExtensionsDbContext)
+dotnet ef migrations add <Name> --context ExtensionsDbContext -p src/{{ProjectName}}.Infrastructure -s src/{{ProjectName}}.Api -o Persistence/Migrations
+
+# Update database
+dotnet ef database update --context ExtensionsDbContext -p src/{{ProjectName}}.Infrastructure -s src/{{ProjectName}}.Api
+
+# Remove last migration
+dotnet ef migrations remove --context ExtensionsDbContext -p src/{{ProjectName}}.Infrastructure -s src/{{ProjectName}}.Api
+```
+
+## Rules
+
+1. **ALL** EF configurations in `Configurations/` folder, organized by feature
+2. **NO** data annotations on entities - use Fluent API only
+3. **Repositories** implement interfaces from Application
+4. **DbContext** implements `IExtensionsDbContext` from Application
+5. **Migrations** stay in this project under `Persistence/Migrations/`
+6. **SQL objects via SqlObjectHelper** - TVFs/views use `SqlObjectHelper.ApplyAll(migrationBuilder)` and embedded `.sql` files
+7. **NO sequential/deterministic GUIDs in seed data** - All GUIDs must be generated via `[guid]::NewGuid()`
+8. **Schema prefix pattern** - Table names use format `{prefix}_{EntityName}` with schema `extensions`. Use `SchemaConstants.Extensions` constant.
+
+## When Adding New Entity
+
+1. Create entity in `{{ProjectName}}.Domain` with factory method
+2. Create repository interface in `{{ProjectName}}.Application/Common/Interfaces/Persistence/`
+3. Add `DbSet<Entity>` to `ExtensionsDbContext`
+4. Create configuration in `Persistence/Configurations/{Feature}/{Entity}Configuration.cs`
+5. Create repository in `Persistence/Repositories/{Entity}Repository.cs` (if needed)
+6. Register repository in `DependencyInjection.cs`
+7. Create migration: `/efcore:migration Add{Entity}`
+8. Run `/efcore:db-deploy` to apply migration