OpenFeature integration

Requires WestyxNexus.OpenFeature v0.10.0 or later alongside WestyxNexus.

The WestyxNexus.OpenFeature package provides NexusProvider, an OpenFeature-compliant FeatureProvider that wraps an existing NexusClient. Config resolutions are served from the client’s local in-memory cache; a boolean evaluation is resolved per user through the AB Testing add-on when the EvaluationContext carries a targeting key.

Installation

dotnet add package WestyxNexus.OpenFeature

Both WestyxNexus and WestyxNexus.OpenFeature must be installed. They are separate NuGet packages from the same GitLab registry.

Quick start

using OpenFeature;
using Westyx.Nexus;
using Westyx.Nexus.OpenFeature;

// Create and start the Nexus client as usual.
await using var nexus = await NexusClient.CreateAsync(new NexusConfig
{
    BaseUrl = "https://blue-ocean-a5rx7.westyx.dev",
    ApiKey  = "wxs_...",
});
nexus.ConnectStream();   // recommended - keeps flags up to date over SSE

// Register the provider once, at startup.
await Api.Instance.SetProviderAsync(new NexusProvider(nexus));

// Evaluate flags anywhere via the OpenFeature client.
var client = Api.Instance.GetClient();
bool enabled = await client.GetBooleanValue("new.checkout", false);

Value mapping

OpenFeature type	OpenFeature method	Nexus source
Boolean	`GetBooleanValue`	`FindFlag(key)`, or `EvaluateABAsync` when the context carries a targeting key
String	`GetStringValue`	`GetConfig(key)` - JSON string value
Double	`GetDoubleValue`	`GetConfig(key)` - JSON number value
Integer	`GetIntegerValue`	`GetConfig(key)` - JSON integer value
Structure	`GetObjectValue`	`GetConfig(key)` - any JSON value; objects become structures and arrays become lists, recursively

Flags vs configs: Boolean resolution reads the feature flag cache, or evaluates per user when the context carries a targeting key. All other types use GetConfig (the config cache).

Error handling

Scenario	`ErrorType`	`Reason`
Flag/config key not found	`FlagNotFound`	`Default` (default value returned)
Config value has wrong JSON type	`TypeMismatch`	`Error` (default value returned)
Successful evaluation	`None`	`Static`, or one of the targeting reasons below

The provider never throws; it always returns a ResolutionDetails<T> with the appropriate error type set.

Per-user targeting

When the EvaluationContext carries a targeting key, a boolean evaluation is resolved for that user through the AB Testing add-on: the flag’s rollout percentage and cohort rules are applied to that identity. Without a targeting key the synced snapshot is read, as it always has been.

var context = EvaluationContext.Builder()
    .SetTargetingKey("user-1234")
    .Set("plan", "pro")
    .Set("region", "eu")
    .Build();

bool enabled = await client.GetBooleanValue("new.checkout", false, context);

Cohort attribute values are compared as strings, so pass strings: a non-string context attribute is left out of the evaluation and reported through the provider’s logger. Format the value at the call site - age.ToString(CultureInfo.InvariantCulture) rather than age - and you know exactly what the cohort rule is matched against. Only boolean evaluation is targeted. String, double, integer and structure values come from configs, and a config has no per-user dimension in Nexus.

Requests and caching

A targeted evaluation is a network call where the snapshot path is a dictionary lookup. Two things keep that affordable, and neither needs configuring: one request serves every flag the snapshot knows for that user, so reading five flags while handling a request costs one round trip; and results are memoised per user and flag for 30 seconds, with concurrent evaluations for the same user coalescing into a single request.

await Api.Instance.SetProviderAsync(new NexusProvider(nexus, new NexusProviderOptions
{
    TargetingTtl     = TimeSpan.FromSeconds(10),
    MaxTargetingKeys = 50_000,
    LoggerFactory    = loggerFactory,
}));

Values that cannot work are rejected at construction, naming the property - a zero TargetingTtl would turn every evaluation into a network call.

Reason codes

Reason	When
`Static`	resolved from the synced snapshot - no targeting key, or the project does not have the AB Testing add-on
`TargetingMatch`	freshly evaluated for this user
`Cached`	served from the provider’s memo
`STALE`	the targeted request failed, so the snapshot value was served instead

A failed targeted request never surfaces as an error. The OpenFeature SDK answers an error resolution by returning the caller’s default, so a flag that is genuinely on would evaluate off because of one failed request; the snapshot value with a STALE reason is the honest answer and the better one. A project without the AB Testing add-on gets Static from the snapshot, and the provider stops asking for five minutes before trying again. SPLIT is never reported: the endpoint returns booleans only, so a rollout bucket and a cohort match are indistinguishable here, and TargetingMatch covers both. Variant carries the string form of the resolved value for boolean, string, double and integer resolutions - "true" / "false" for a boolean, lowercase, which is the same spelling every SDK in the Westyx Nexus suite uses. A structure resolution has no variant: a composite value has no short semantic identifier.

ASP.NET Core DI example

using OpenFeature;
using Westyx.Nexus;
using Westyx.Nexus.OpenFeature;

var builder = WebApplication.CreateBuilder(args);

// Register the Nexus client.
builder.Services.AddSingleton(sp =>
{
    var nexus = NexusClient.CreateAsync(new NexusConfig
    {
        BaseUrl = builder.Configuration["Nexus:BaseUrl"]!,
        ApiKey  = builder.Configuration["Nexus:ApiKey"]!,
    }).GetAwaiter().GetResult();
    nexus.ConnectStream();
    return nexus;
});

// Register the OpenFeature provider.
builder.Services.AddSingleton<NexusProvider>(sp =>
    new NexusProvider(sp.GetRequiredService<NexusClient>()));

// Register IFeatureClient for injection into services.
builder.Services.AddSingleton<IFeatureClient>(sp =>
{
    var provider = sp.GetRequiredService<NexusProvider>();
    Api.Instance.SetProviderAsync(provider).GetAwaiter().GetResult();
    return Api.Instance.GetClient();
});

Inject IFeatureClient into your services:

public class CheckoutService(IFeatureClient flags)
{
    public async Task<bool> IsNewCheckoutEnabled()
        => await flags.GetBooleanValue("new.checkout", false);
}

Live updates

When nexus.ConnectStream() is active, the client’s cache is updated within milliseconds of a remote flag change via SSE. OpenFeature evaluations pick up the new value on the next call because the provider reads directly from the live cache.

Overview

Backend SDKs

Browser SDKs

OpenFeature Providers

OpenFeature integration

Installation

Quick start

Value mapping

Error handling

Per-user targeting

Requests and caching

Reason codes

ASP.NET Core DI example

Live updates

​Installation

​Quick start

​Value mapping

​Error handling

​Per-user targeting

​Requests and caching

​Reason codes

​ASP.NET Core DI example

​Live updates

Installation

Quick start

Value mapping

Error handling

Per-user targeting

Requests and caching

Reason codes

ASP.NET Core DI example

Live updates