.NET

dotnet add package Sheepit.Sdk --version 0.1.2

using System.Net.Http.Headers;
using System.Text.Json;
using Sheepit.Sdk;

public sealed class SheepitFlags
{
    private readonly Dictionary<string, RulesetFlag> _flags;

    private SheepitFlags(Dictionary<string, RulesetFlag> flags) => _flags = flags;

    // GET v1/flags/ruleset with a SECRET key (lp_sec_…). Server-side only.
    // http.BaseAddress must END IN "/": the path below is relative, so a base such as
    // https://sheepit.example.com/api/ keeps its /api/ prefix.
    public static async Task<SheepitFlags> FetchAsync(HttpClient http, string secretKey)
    {
        using var request = new HttpRequestMessage(HttpMethod.Get, "v1/flags/ruleset");
        request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", secretKey);
        using HttpResponseMessage response = await http.SendAsync(request);
        response.EnsureSuccessStatusCode();

        using JsonDocument doc = JsonDocument.Parse(await response.Content.ReadAsStringAsync());
        JsonElement data = doc.RootElement.GetProperty("data");

        // Refuse a snapshot this package was not built to bucket.
        int version = data.GetProperty("bucketing_version").GetInt32();
        if (version != Bucketing.Version)
            throw new NotSupportedException($"ruleset bucketing_version {version}, SDK implements {Bucketing.Version}");

        return new SheepitFlags(data.GetProperty("flags").EnumerateArray()
            .Select(ToFlag)
            .ToDictionary(f => f.Key));
    }

    public object? Evaluate(
        string flagKey,
        string? userId,
        string? deviceId,
        IReadOnlyDictionary<string, object?> context,
        object? callerDefault)
    {
        // No identity -> the caller's default. Never skip the rollout instead.
        string? identity = Bucketing.Identity(userId, deviceId);
        if (identity is null) return callerDefault;

        _flags.TryGetValue(flagKey, out RulesetFlag? flag);
        return RulesetEvaluator.Evaluate(flag, identity, context, callerDefault).Value;
    }

    private static RulesetFlag ToFlag(JsonElement f) => new(
        f.GetProperty("key").GetString()!,
        f.GetProperty("value_type").GetString()!,
        JsValue.FromJson(f.GetProperty("default_value")),
        f.GetProperty("killed").GetBoolean(),
        [.. f.GetProperty("rules").EnumerateArray().Select(r => new RulesetRule(
            r.GetProperty("id").GetString()!,
            r.GetProperty("sort_order").GetDouble(),
            Conditions(r),
            r.TryGetProperty("value", out JsonElement v) ? JsValue.FromJson(v) : null,
            r.TryGetProperty("enabled", out JsonElement en) && en.ValueKind != JsonValueKind.Null
                ? en.GetBoolean()
                : null))],
        [.. f.GetProperty("rollouts").EnumerateArray().Select(r => new RulesetRollout(
            r.GetProperty("id").GetString()!,
            r.GetProperty("current_pct").GetDouble(),
            Conditions(r),
            r.TryGetProperty("value", out JsonElement v) ? JsValue.FromJson(v) : null,
            // Absent status = active (null). A JSON null status is NOT active: map it to "".
            !r.TryGetProperty("status", out JsonElement s) ? null
                : s.ValueKind == JsonValueKind.Null ? "" : s.GetString(),
            r.TryGetProperty("has_user_overrides", out JsonElement h) && h.GetBoolean()))]);

    private static List<RuleCondition> Conditions(JsonElement owner) =>
        [.. owner.GetProperty("conditions").EnumerateArray().Select(c => new RuleCondition(
            c.GetProperty("field").GetString()!,
            c.GetProperty("op").GetString()!,
            [.. c.GetProperty("values").EnumerateArray().Select(JsValue.FromJson)]))];
}

public static class Example
{
    public static async Task<bool> IsNewCheckoutOnAsync(HttpClient http, string secretKey, string userId)
    {
        // http.BaseAddress = https://api.sheepit.ai/ (trailing slash). Fetch once and reuse; this package does not poll.
        SheepitFlags flags = await SheepitFlags.FetchAsync(http, secretKey);

        var context = new Dictionary<string, object?>
        {
            ["country"] = "AR",
            ["attributes"] = new Dictionary<string, object?> { ["plan"] = "pro", ["seats"] = 12d },
        };

        return flags.Evaluate("new_checkout", userId, deviceId: null, context, callerDefault: false) is true;
    }
}