Contributing to Queryly

git checkout -b feature/your-feature-name

# Run all tests
dotnet test

# Run specific test file
dotnet test --filter "FullyQualifiedName~SqliteConnectionProviderTests"

# Run with verbose output
dotnet test -v detailed

git add .
git commit -m "Add support for MySQL connection pooling"

git fetch upstream
git rebase upstream/main

git push origin feature/your-feature-name

// Classes and interfaces - PascalCase
public class ConnectionManager { }
public interface IConnectionProvider { }

// Methods - PascalCase
public async Task OpenConnectionAsync() { }

// Properties - PascalCase
public string ConnectionString { get; set; }

// Private fields - camelCase with underscore
private string _connectionString;

// Local variables - camelCase
var tableName = "users";

// Constants - PascalCase
public const int MaxRetries = 3;

// 1. Using statements
using System.Data.Common;
using Microsoft.Data.Sqlite;

// 2. Namespace
namespace Queryly.Providers.Sqlite;

// 3. Class definition
public class SqliteConnectionProvider : IConnectionProvider
{
    // 4. Fields
    private readonly string _connectionString;
    
    // 5. Properties
    public DatabaseType Type => DatabaseType.SQLite;
    
    // 6. Constructors
    public SqliteConnectionProvider(string connectionString)
    {
        _connectionString = connectionString;
    }
    
    // 7. Public methods
    public async Task<DbConnection> OpenConnectionAsync()
    {
        // Implementation
    }
    
    // 8. Private methods
    private void ValidateConnectionString()
    {
        // Implementation
    }
}

// Good
public async Task<List<TableInfo>> GetTablesAsync(DbConnection connection)
{
    var tables = new List<TableInfo>();
    using var reader = await command.ExecuteReaderAsync();
    while (await reader.ReadAsync())
    {
        // Process data
    }
    return tables;
}

// Avoid
public List<TableInfo> GetTables(DbConnection connection)
{
    // Synchronous database access
}

// Good
try
{
    await connection.OpenAsync();
}
catch (SqliteException ex)
{
    throw new ConnectionException(
        $"Failed to open SQLite database at '{filePath}': {ex.Message}", 
        ex
    );
}

// Avoid
catch (Exception ex)
{
    throw new Exception("Error", ex);
}

// Good
using var connection = new SqliteConnection(connectionString);
await connection.OpenAsync();

// Also good
using (var connection = new SqliteConnection(connectionString))
{
    await connection.OpenAsync();
    // Use connection
}

/// <summary>
/// Opens a connection to the database using the provided connection string.
/// </summary>
/// <param name="connectionString">The database connection string.</param>
/// <returns>An open database connection.</returns>
/// <exception cref="ArgumentException">Thrown when connection string is null or empty.</exception>
/// <exception cref="ConnectionException">Thrown when connection fails.</exception>
public async Task<DbConnection> OpenConnectionAsync(string connectionString)
{
    // Implementation
}

using Xunit;
using FluentAssertions;

namespace Queryly.Tests.Providers;

public class SqliteConnectionProviderTests
{
    [Fact]
    public async Task OpenConnectionAsync_WithValidConnectionString_ReturnsOpenConnection()
    {
        // Arrange
        var provider = new SqliteConnectionProvider();
        var connectionString = "Data Source=:memory:";
        
        // Act
        var connection = await provider.OpenConnectionAsync(connectionString);
        
        // Assert
        connection.Should().NotBeNull();
        connection.State.Should().Be(ConnectionState.Open);
        
        // Cleanup
        await connection.DisposeAsync();
    }
    
    [Theory]
    [InlineData(null)]
    [InlineData("")]
    [InlineData("   ")]
    public async Task OpenConnectionAsync_WithInvalidConnectionString_ThrowsException(
        string connectionString)
    {
        // Arrange
        var provider = new SqliteConnectionProvider();
        
        // Act & Assert
        await Assert.ThrowsAsync<ArgumentException>(
            () => provider.OpenConnectionAsync(connectionString)
        );
    }
}

# Run all tests in a class
dotnet test --filter "FullyQualifiedName~SqliteConnectionProviderTests"

# Run a specific test
dotnet test --filter "FullyQualifiedName~OpenConnectionAsync_WithValidConnectionString"

# Run tests with coverage
dotnet test /p:CollectCoverage=true

queryly/
├── src/
│   ├── Queryly.CLI/              # CLI interface
│   │   ├── Commands/             # Command implementations
│   │   │   ├── ConnectCommands/  # Connection commands
│   │   │   ├── SchemaCommands/   # Schema commands
│   │   │   └── DataCommands/     # Data commands
│   │   ├── Configuration/        # Config helpers
│   │   └── Program.cs            # Entry point
│   ├── Queryly.Core/             # Business logic
│   │   ├── Models/               # Data models
│   │   ├── Connections/          # Connection interfaces
│   │   ├── Query/                # Query execution
│   │   └── Exceptions/           # Custom exceptions
│   └── Queryly.Providers/        # Database providers
│       ├── Sqlite/               # SQLite
│       ├── SqlServer/            # SQL Server
│       ├── PostgreSql/           # PostgreSQL
│       └── MySql/                # MySQL
├── tests/
│   └── Queryly.Tests/            # Unit tests
├── docs/                         # Documentation
└── README.md                     # Main readme

# Restore dependencies
dotnet restore

# Build entire solution
dotnet build

# Build specific project
dotnet build src/Queryly.CLI/Queryly.CLI.csproj

# Run all tests
dotnet test

# Run with detailed output
dotnet test -v detailed

# Run CLI
dotnet run --project src/Queryly.CLI/Queryly.CLI.csproj

# Clean build artifacts
dotnet clean

# Publish for current platform
dotnet publish -c Release

# Publish for specific platform
dotnet publish -c Release -r win-x64
dotnet publish -c Release -r linux-x64
dotnet publish -c Release -r osx-x64