SparkToolkit 1.0.3

🔥 SPARK – Service Pack and Rapid Kit

SPARK is a powerful, opinionated starter toolkit for building enterprise-grade microservices with .NET 8. It provides essential configurations, integrated libraries, and best practices to accelerate development while maintaining consistency and quality across your microservices architecture.

✨ Key Features

🏗️ Core Infrastructure

• ✅ Centralized Configuration - Structured settings management with validation
• 🎯 Dependency Injection - Advanced DI patterns with service discovery
• 🛡️ Global Exception Handling - Comprehensive error management middleware
• 📊 API Versioning - Built-in versioning support with Swagger documentation

🔄 Message Queues & Communication

• 🐰 RabbitMQ Integration - Full MassTransit support with consumer discovery
• 📨 Redis Pub/Sub - High-performance message publishing and subscription
• ⚡ Apache Kafka - Enterprise-grade streaming platform support
• 🎭 MediatR CQRS - Command/Query pattern with pipeline behaviors

💾 Data Access & Storage

• 🐘 PostgreSQL - Entity Framework Core with advanced configurations
• 🍃 MongoDB - Document database support with repository patterns
• 🔴 Redis Caching - Distributed caching with connection multiplexing
• 📋 Repository Pattern - Abstracted data access layer

🔐 Security & Authentication

• 🔑 JWT Authentication - Token-based authentication with Bearer support
• 🛡️ Authorization - Role-based and policy-based access control
• 🌐 CORS Configuration - Environment-based CORS policies

🧪 Development & Documentation

• 📖 Swagger/OpenAPI - Auto-generated API documentation with Scalar UI
• ✅ FluentValidation - Comprehensive model validation
• 🗺️ AutoMapper - Object mapping with profile configurations
• 🔧 Background Services - Scalable background task processing

📦 Installation

dotnet add package SparkToolkit

🚀 Quick Start

1. Initial Setup

# First time setup
.\setup.ps1

2. Basic Usage

var builder = WebApplication.CreateBuilder(args);

// Add SPARK libraries
builder.AddLibrary();

var app = builder.Build();

// Use SPARK middleware and configurations
await app.UseLibrary();

2. Configuration Setup

Add the following sections to your appsettings.json:

{
  "DocumentApiSetting": {
    "Title": "My Microservice API",
    "Description": "A powerful microservice built with SPARK"
  },
  "RedisSetting": {
    "ClientName": "MyService",
    "Host": "localhost",
    "Port": 6379,
    "User": "default",
    "Password": "your-password"
  },
  "RabbitMqSetting": {
    "Host": "localhost",
    "Username": "guest",
    "Password": "guest",
    "Port": 5672
  },
  "PostgresSetting": {
    "ConnectionString": "Host=localhost;Database=mydb;Username=postgres;Password=password",
    "CommandTimeout": 30,
    "RetryCount": 3,
    "RetryDelay": 1000
  },
  "MongoSetting": {
    "Username": "admin",
    "Password": "password",
    "Host": "localhost",
    "Port": "27017",
    "DatabaseName": "mydatabase"
  },
  "JwtSetting": {
    "SecurityKey": "your-super-secret-key-here",
    "Issuer": "your-issuer",
    "Audience": "your-audience",
    "TokenExpiry": 3600,
    "RefreshTokenExpiry": 86400
  },
  "WorkerSetting": {
    "MinWorkerCount": 1,
    "MaxWorkerCount": 10,
    "ScaleInterval": 1800,
    "TaskThresholdToScaleUp": 50,
    "TaskThresholdToScaleDown": 20
  }
}

🔧 Advanced Usage

Message Queue Integration

RabbitMQ with MassTransit

builder.Services.AddMassTransitWithRabbitMq(
    builder.Configuration,
    typeof(Program).Assembly  // Consumer assemblies
);

Redis Pub/Sub

// Register Redis Pub/Sub
builder.Services.AddRedisPubSub();

// Register message handlers
builder.Services.AddRedisMessageHandlers(typeof(Program).Assembly);

// Or register specific handlers
builder.Services.AddRedisMessageHandler<MyMessageHandler>("my-channel");

MediatR with Behaviors

builder.Services.AddMediatr(typeof(Program).Assembly);

Includes built-in behaviors:

• Validation Behavior - FluentValidation integration
• Caching Behavior - Automatic response caching
• Transaction Behavior - Database transaction management

Entity Framework Configuration

public class MyEntity : BaseAuditableEntity<Guid>
{
    public string Name { get; set; } = string.Empty;
    public string Description { get; set; } = string.Empty;
}

public class MyEntityConfiguration : BaseConfiguration<MyEntity, Guid>
{
    public override void Configure(EntityTypeBuilder<MyEntity> builder)
    {
        base.Configure(builder);
        
        builder.Property(e => e.Name)
               .HasMaxLength(200)
               .IsRequired();
    }
}

Background Services

// Auto-scaling background worker
builder.Services.AddHostedService<WorkerService<MyTaskQueue>>();

📁 Project Structure

Spark.Core/                    # Core abstractions and models
├── Attributes/                # Custom attributes for caching, messaging
├── Constants/                 # Application constants and enums
├── Extensions/                # Extension methods
├── Models/                    # DTOs, settings, and response models
└── SeedWorks/                 # Base entities and abstractions

Spark.Libraries/               # Implementation libraries
├── BackgroundServices/        # Background task processing
├── Cache/                     # Redis caching implementation
├── DocumentApi/               # Swagger/OpenAPI configuration
├── EntityFramework/           # EF Core configurations
├── Mediatr/                   # MediatR pipeline behaviors
├── MessageQueues/             # RabbitMQ & Redis Pub/Sub
├── Middlewares/               # Custom middleware
├── Mongo/                     # MongoDB support
└── Repositories/              # Repository pattern implementation

🎯 Core Concepts

Base Entities

All entities inherit from base classes providing:

• Audit Fields - Created/Updated timestamps with user tracking
• Soft Delete - Logical deletion support
• Concurrency Control - Optimistic locking with row versioning

Message Handling

• Automatic Discovery - Handlers are automatically registered via reflection
• Typed Messages - Strong typing with ITypedMessageHandler<T>
• Channel-based Routing - Redis Pub/Sub with channel-specific handlers

Caching Strategy

• Distributed Caching - Redis-based caching with connection pooling
• Attribute-based - Method-level caching with [Cache] attribute
• Invalidation Support - Smart cache invalidation patterns

🌍 Environment Configuration

SPARK supports environment-specific configurations:

• Development - Full Swagger UI with Scalar documentation
• Production - Optimized settings with security headers
• Staging - Balanced configuration for testing

🤝 Contributing

1. Fork the repository
2. Create a feature branch (git checkout -b feature/amazing-feature)
3. Commit your changes (git commit -m 'Add some amazing feature')
4. Push to the branch (git push origin feature/amazing-feature)
5. Open a Pull Request

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

🆘 Support

• 📧 Email: support.study@gmail.com
• 🌐 Website: max-h.vercel.app
• 📚 Documentation: [Coming Soon]

🔮 Roadmap

• OpenTelemetry Integration - Distributed tracing support
• Health Checks - Comprehensive health monitoring
• Metrics Collection - Prometheus/Grafana integration
• Service Discovery - Consul/Eureka support
• Rate Limiting - API throttling capabilities
• Event Sourcing - Event-driven architecture patterns

Built with ❤️ for the .NET community