Noundry.Connector

# Install globally
dotnet tool install -g Noundry.Connector.Generator

# Verify installation
noundry-connector --version

# Start the generator
noundry-connector generate

# Follow the interactive prompts:
# > API URL: https://jsonplaceholder.typicode.com
# > Client Name: JsonPlaceholderClient  
# > Namespace: MyApp.ApiClients
# > Output Directory: ./Generated
# > Authentication: None (public API)

# Or use command line options:
noundry-connector generate \
  --url "https://jsonplaceholder.typicode.com" \
  --client-name "JsonPlaceholderClient" \
  --namespace "MyApp.ApiClients" \
  --output "./Generated" \
  --auth-type "None"

Generated/
├── Models/
│   ├── Post.cs
│   ├── User.cs
│   ├── Comment.cs
│   └── Album.cs
├── Interfaces/
│   └── IJsonPlaceholderClient.cs
├── JsonPlaceholderClient.cs
└── ServiceCollectionExtensions.cs

# Add the core library
dotnet add package Noundry.Connector

# Copy generated files to your project
cp -r Generated/* src/MyApp/

# Or include them directly from the Generated folder

// In Program.cs or Startup.cs
using MyApp.ApiClients;

var builder = WebApplication.CreateBuilder(args);

// Register the generated client
builder.Services.AddJsonPlaceholderClient("https://jsonplaceholder.typicode.com");

var app = builder.Build();

using MyApp.ApiClients;
using MyApp.ApiClients.Models;

public class BlogService
{
    private readonly IJsonPlaceholderClient _apiClient;

    public BlogService(IJsonPlaceholderClient apiClient)
    {
        _apiClient = apiClient;
    }

    public async Task<IEnumerable<Post>> GetUserPostsAsync(int userId)
    {
        var posts = await _apiClient.GetPostsAsync();
        return posts.Where(p => p.UserId == userId);
    }

    public async Task<Post> CreatePostAsync(Post post)
    {
        return await _apiClient.CreatePostAsync(post);
    }

    public async Task UpdatePostAsync(int id, Post post)
    {
        await _apiClient.UpdatePostAsync(id, post);
    }

    public async Task DeletePostAsync(int id)
    {
        await _apiClient.DeletePostAsync(id);
    }
}

// 1. Define your model
public class User
{
    [JsonPropertyName("id")]
    public int Id { get; set; }

    [JsonPropertyName("email")]
    public string Email { get; set; }

    [JsonPropertyName("name")]
    public string Name { get; set; }
}

// 2. Define Refit interface
public interface IUserApi
{
    [Get("/users")]
    Task<IEnumerable<User>> GetUsersAsync(CancellationToken cancellationToken = default);

    [Get("/users/{id}")]
    Task<User> GetUserAsync(int id, CancellationToken cancellationToken = default);

    [Post("/users")]
    Task<User> CreateUserAsync([Body] User user);
}

// 3. Register in DI
services.AddConnector<IUserApi>(options =>
{
    options.BaseUrl = "https://api.example.com";
    options.Timeout = TimeSpan.FromSeconds(30);
});

// Bearer Token Authentication
services.AddTokenAuthentication("your-api-token");

services.AddConnector<IYourApi>(options =>
{
    options.BaseUrl = "https://api.example.com";
    options.DefaultHeaders["User-Agent"] = "MyApp/1.0.0";
});

// Inject and use
var api = serviceProvider.GetRequiredService<IYourApi>();
var data = await api.GetDataAsync();

// Configure OAuth 2.0 for GitHub API
services.AddOAuthAuthentication(config =>
{
    config.ClientId = configuration["GitHub:ClientId"];
    config.ClientSecret = configuration["GitHub:ClientSecret"];
    config.TokenEndpoint = "https://github.com/login/oauth/access_token";
    config.Scope = "repo user:email";
});

// Configure GitHub API client
services.AddConnector<IGitHubApi>(options =>
{
    options.BaseUrl = "https://api.github.com";
    options.DefaultHeaders["Accept"] = "application/vnd.github.v3+json";
});

public class ECommerceService
{
    private readonly IProductApi _productApi;
    private readonly IOrderApi _orderApi;

    public async Task<List<Product>> GetPersonalizedRecommendationsAsync(int customerId)
    {
        // Get customer order history
        var orders = await _orderApi.GetCustomerOrdersAsync(customerId);
        var allProducts = await _productApi.GetProductsAsync();

        // Analyze purchase patterns
        var purchasedProductIds = orders
            .SelectMany(o => o.Items)
            .Select(item => item.ProductId)
            .Distinct()
            .ToHashSet();

        var preferredCategories = orders
            .SelectMany(o => o.Items)
            .Join(allProducts, item => item.ProductId, product => product.Id,
                  (item, product) => product.CategoryId)
            .GroupBy(categoryId => categoryId)
            .OrderByDescending(g => g.Count())
            .Take(3)
            .Select(g => g.Key)
            .ToList();

        // Generate recommendations
        return allProducts
            .Where(p => !purchasedProductIds.Contains(p.Id))
            .Where(p => preferredCategories.Contains(p.CategoryId))
            .OrderByDescending(p => p.Rating)
            .Take(10)
            .ToList();
    }
}

public async Task<ViralContentReport> AnalyzeViralContentAsync(DateTime startDate, DateTime endDate)
{
    var posts = await _postApi.GetPostsByDateRangeAsync(startDate, endDate);
    var engagements = await _engagementApi.GetEngagementsByDateRangeAsync(startDate, endDate);

    // Identify viral content
    var viralPosts = posts
        .Select(post => new {
            Post = post,
            TotalEngagements = engagements
                .Where(e => e.PostId == post.Id)
                .Sum(e => e.Count),
            EngagementRate = engagements
                .Where(e => e.PostId == post.Id)
                .Sum(e => e.Count) / (double)post.ViewCount
        })
        .Where(p => p.TotalEngagements > 1000 && p.EngagementRate > 0.05)
        .OrderByDescending(p => p.TotalEngagements)
        .Take(50)
        .ToList();

    return new ViralContentReport
    {
        ViralPosts = viralPosts.Select(vp => vp.Post).ToList(),
        AverageEngagementRate = viralPosts.Average(vp => vp.EngagementRate)
    };
}