refactor(go): Move sticky resolve handling logic to provider level

Address review feedback by moving the sticky resolve response handling
logic from SwapWasmResolverApi to LocalResolverProvider.

Changes:
- Update WasmResolverApi.ResolveWithSticky to return ResolveWithStickyResponse
  instead of ResolveFlagsResponse
- Move response handling logic (Success/MissingMaterializations) from
  SwapWasmResolverApi to LocalResolverProvider
- Add handleStickyResponse, storeUpdates, and handleMissingMaterializations
  methods to LocalResolverProvider
- Remove sticky strategy parameter from NewSwapWasmResolverApi
- Update all tests to work with the new interface
- Remove obsolete sticky_resolve_strategy_test.go (logic now tested at
  provider level)

This separates concerns: SwapWasmResolverApi is now only responsible for
managing WASM instances, while LocalResolverProvider handles the business
logic for sticky resolve strategies.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[email protected]>

Author: fabriziodemaria

openfeature-provider/go/confidence/integration_test.go

@@ -191,7 +191,7 @@ func createProviderWithTestState(
 	runtime := wazero.NewRuntimeWithConfig(ctx, runtimeConfig)
 
 	// Create SwapWasmResolverApi without initial state (lazy initialization)
-	resolverAPI, err := NewSwapWasmResolverApi(ctx, runtime, defaultWasmBytes, logger, slog.New(slog.NewTextHandler(os.Stderr, nil)), nil)
+	resolverAPI, err := NewSwapWasmResolverApi(ctx, runtime, defaultWasmBytes, logger, slog.New(slog.NewTextHandler(os.Stderr, nil)))
 	if err != nil {
 		return nil, err
 	}

openfeature-provider/go/confidence/local_resolver_provider.go

@@ -280,7 +280,7 @@ func (p *LocalResolverProvider) ObjectEvaluation(
 	}
 
 	// Resolve flags with sticky support
-	response, err := p.resolverAPI.ResolveWithSticky(ctx, stickyRequest)
+	stickyResponse, err := p.resolverAPI.ResolveWithSticky(ctx, stickyRequest)
 	if err != nil {
 		p.logger.Error("Failed to resolve flag", "flag", flagPath, "error", err)
 		return openfeature.InterfaceResolutionDetail{
@@ -292,6 +292,19 @@ func (p *LocalResolverProvider) ObjectEvaluation(
 		}
 	}
 
+	// Handle the sticky response and extract the actual resolve response
+	response, err := p.handleStickyResponse(ctx, stickyRequest, stickyResponse)
+	if err != nil {
+		p.logger.Error("Failed to handle sticky response", "flag", flagPath, "error", err)
+		return openfeature.InterfaceResolutionDetail{
+			Value: defaultValue,
+			ProviderResolutionDetail: openfeature.ProviderResolutionDetail{
+				Reason:          openfeature.ErrorReason,
+				ResolutionError: openfeature.NewGeneralResolutionError(fmt.Sprintf("resolve failed: %v", err)),
+			},
+		}
+	}
+
 	// Check if flag was found
 	if len(response.ResolvedFlags) == 0 {
 		p.logger.Info("No active flag was found", "flag", flagPath)
@@ -448,6 +461,145 @@ func (p *LocalResolverProvider) Shutdown() {
 	}
 }
 
+// handleStickyResponse processes the sticky response and returns the actual resolve response
+func (p *LocalResolverProvider) handleStickyResponse(
+	ctx context.Context,
+	request *resolver.ResolveWithStickyRequest,
+	stickyResponse *resolver.ResolveWithStickyResponse,
+) (*resolver.ResolveFlagsResponse, error) {
+	// Handle the response based on result type
+	switch result := stickyResponse.ResolveResult.(type) {
+	case *resolver.ResolveWithStickyResponse_Success_:
+		success := result.Success
+		// Store updates if present and we have a MaterializationRepository
+		if len(success.GetUpdates()) > 0 {
+			p.storeUpdates(ctx, success.GetUpdates())
+		}
+		return success.Response, nil
+
+	case *resolver.ResolveWithStickyResponse_MissingMaterializations_:
+		missingMaterializations := result.MissingMaterializations
+
+		// Check for ResolverFallback first - return early if so
+		if fallback, ok := p.stickyResolveStrategy.(ResolverFallback); ok {
+			return fallback.Resolve(ctx, request.GetResolveRequest())
+		}
+
+		// Handle MaterializationRepository case
+		if repo, ok := p.stickyResolveStrategy.(MaterializationRepository); ok {
+			updatedRequest, err := p.handleMissingMaterializations(ctx, request, missingMaterializations.GetItems(), repo)
+			if err != nil {
+				return nil, fmt.Errorf("failed to handle missing materializations: %w", err)
+			}
+			// Retry with the updated request
+			retryResponse, err := p.resolverAPI.ResolveWithSticky(ctx, updatedRequest)
+			if err != nil {
+				return nil, err
+			}
+			// Recursively handle the response (in case there are more missing materializations)
+			return p.handleStickyResponse(ctx, updatedRequest, retryResponse)
+		}
+
+		// If no strategy is configured, return an error
+		if p.stickyResolveStrategy == nil {
+			return nil, fmt.Errorf("missing materializations and no sticky resolve strategy configured")
+		}
+
+		return nil, fmt.Errorf("unknown sticky resolve strategy type: %T", p.stickyResolveStrategy)
+
+	default:
+		return nil, fmt.Errorf("unexpected resolve result type: %T", stickyResponse.ResolveResult)
+	}
+}
+
+// storeUpdates stores materialization updates asynchronously if we have a MaterializationRepository
+func (p *LocalResolverProvider) storeUpdates(ctx context.Context, updates []*resolver.ResolveWithStickyResponse_MaterializationUpdate) {
+	repo, ok := p.stickyResolveStrategy.(MaterializationRepository)
+	if !ok {
+		return
+	}
+
+	// Store updates asynchronously
+	go func() {
+		// Group updates by unit
+		updatesByUnit := make(map[string][]*resolver.ResolveWithStickyResponse_MaterializationUpdate)
+		for _, update := range updates {
+			updatesByUnit[update.GetUnit()] = append(updatesByUnit[update.GetUnit()], update)
+		}
+
+		// Store assignments for each unit
+		for unit, unitUpdates := range updatesByUnit {
+			assignments := make(map[string]*MaterializationInfo)
+			for _, update := range unitUpdates {
+				ruleToVariant := map[string]string{update.GetRule(): update.GetVariant()}
+				assignments[update.GetWriteMaterialization()] = &MaterializationInfo{
+					UnitInMaterialization: true,
+					RuleToVariant:         ruleToVariant,
+				}
+			}
+
+			if err := repo.StoreAssignment(ctx, unit, assignments); err != nil {
+				p.logger.Error("Failed to store materialization updates",
+					"unit", unit,
+					"error", err)
+			}
+		}
+	}()
+}
+
+// handleMissingMaterializations loads missing materializations from the repository
+// and returns an updated request with the materializations added
+func (p *LocalResolverProvider) handleMissingMaterializations(
+	ctx context.Context,
+	request *resolver.ResolveWithStickyRequest,
+	missingItems []*resolver.ResolveWithStickyResponse_MissingMaterializationItem,
+	repo MaterializationRepository,
+) (*resolver.ResolveWithStickyRequest, error) {
+	// Group missing items by unit for efficient loading
+	missingByUnit := make(map[string][]*resolver.ResolveWithStickyResponse_MissingMaterializationItem)
+	for _, item := range missingItems {
+		missingByUnit[item.GetUnit()] = append(missingByUnit[item.GetUnit()], item)
+	}
+
+	// Create the materializations per unit map
+	materializationsPerUnit := make(map[string]*resolver.MaterializationMap)
+
+	// Copy existing materializations
+	for k, v := range request.GetMaterializationsPerUnit() {
+		materializationsPerUnit[k] = v
+	}
+
+	// Load materialized assignments for all missing units
+	for unit, items := range missingByUnit {
+		for _, item := range items {
+			loadedAssignments, err := repo.LoadMaterializedAssignmentsForUnit(ctx, unit, item.GetReadMaterialization())
+			if err != nil {
+				return nil, fmt.Errorf("failed to load materializations for unit %s: %w", unit, err)
+			}
+
+			// Ensure the map exists for this unit
+			if materializationsPerUnit[unit] == nil {
+				materializationsPerUnit[unit] = &resolver.MaterializationMap{
+					InfoMap: make(map[string]*resolver.MaterializationInfo),
+				}
+			}
+
+			// Add loaded assignments to the materialization map
+			for name, info := range loadedAssignments {
+				materializationsPerUnit[unit].InfoMap[name] = info.ToProto()
+			}
+		}
+	}
+
+	// Create a new request with the updated materializations
+	return &resolver.ResolveWithStickyRequest{
+		ResolveRequest:          request.GetResolveRequest(),
+		MaterializationsPerUnit: materializationsPerUnit,
+		FailFastOnSticky:        request.GetFailFastOnSticky(),
+		NotProcessSticky:        request.GetNotProcessSticky(),
+	}, nil
+}
+
 // startScheduledTasks starts the background tasks for state fetching and log polling
 func (p *LocalResolverProvider) startScheduledTasks(parentCtx context.Context) {
 	ctx, cancel := context.WithCancel(parentCtx)

openfeature-provider/go/confidence/local_resolver_provider_resolve_test.go

@@ -34,7 +34,7 @@ func TestLocalResolverProvider_ReturnsDefaultOnError(t *testing.T) {
 	stateBytes, _ := proto.Marshal(state)
 
 	flagLogger := NewNoOpWasmFlagLogger()
-	swap, err := NewSwapWasmResolverApi(ctx, runtime, defaultWasmBytes, flagLogger, slog.New(slog.NewTextHandler(os.Stderr, nil)), nil)
+	swap, err := NewSwapWasmResolverApi(ctx, runtime, defaultWasmBytes, flagLogger, slog.New(slog.NewTextHandler(os.Stderr, nil)))
 	if err != nil {
 		t.Fatalf("Failed to create SwapWasmResolverApi: %v", err)
 	}
@@ -85,7 +85,7 @@ func TestLocalResolverProvider_ReturnsCorrectValue(t *testing.T) {
 	testAcctID := loadTestAccountID(t)
 
 	flagLogger := NewNoOpWasmFlagLogger()
-	swap, err := NewSwapWasmResolverApi(ctx, runtime, defaultWasmBytes, flagLogger, slog.New(slog.NewTextHandler(os.Stderr, nil)), nil)
+	swap, err := NewSwapWasmResolverApi(ctx, runtime, defaultWasmBytes, flagLogger, slog.New(slog.NewTextHandler(os.Stderr, nil)))
 	if err != nil {
 		t.Fatalf("Failed to create SwapWasmResolverApi: %v", err)
 	}
@@ -172,7 +172,7 @@ func TestLocalResolverProvider_MissingMaterializations(t *testing.T) {
 		testAcctID := loadTestAccountID(t)
 
 		flagLogger := NewNoOpWasmFlagLogger()
-		swap, err := NewSwapWasmResolverApi(ctx, runtime, defaultWasmBytes, flagLogger, slog.New(slog.NewTextHandler(os.Stderr, nil)), nil)
+		swap, err := NewSwapWasmResolverApi(ctx, runtime, defaultWasmBytes, flagLogger, slog.New(slog.NewTextHandler(os.Stderr, nil)))
 		if err != nil {
 			t.Fatalf("Failed to create SwapWasmResolverApi: %v", err)
 		}
@@ -217,7 +217,7 @@ func TestLocalResolverProvider_MissingMaterializations(t *testing.T) {
 		accountId := "test-account"
 
 		flagLogger := NewNoOpWasmFlagLogger()
-		swap, err := NewSwapWasmResolverApi(ctx, runtime, defaultWasmBytes, flagLogger, slog.New(slog.NewTextHandler(os.Stderr, nil)), nil)
+		swap, err := NewSwapWasmResolverApi(ctx, runtime, defaultWasmBytes, flagLogger, slog.New(slog.NewTextHandler(os.Stderr, nil)))
 		if err != nil {
 			t.Fatalf("Failed to create SwapWasmResolverApi: %v", err)
 		}

openfeature-provider/go/confidence/local_resolver_provider_test.go

@@ -437,7 +437,7 @@ func (m *mockStateProviderForInit) Provide(ctx context.Context) ([]byte, string,
 type mockResolverAPIForInit struct {
 	updateStateFunc   func(state []byte, accountID string) error
 	closeFunc         func(ctx context.Context)
-	resolveWithSticky func(ctx context.Context, request *resolver.ResolveWithStickyRequest) (*resolver.ResolveFlagsResponse, error)
+	resolveWithSticky func(ctx context.Context, request *resolver.ResolveWithStickyRequest) (*resolver.ResolveWithStickyResponse, error)
 }
 
 func (m *mockResolverAPIForInit) UpdateStateAndFlushLogs(state []byte, accountID string) error {
@@ -453,7 +453,7 @@ func (m *mockResolverAPIForInit) Close(ctx context.Context) {
 	}
 }
 
-func (m *mockResolverAPIForInit) ResolveWithSticky(ctx context.Context, request *resolver.ResolveWithStickyRequest) (*resolver.ResolveFlagsResponse, error) {
+func (m *mockResolverAPIForInit) ResolveWithSticky(ctx context.Context, request *resolver.ResolveWithStickyRequest) (*resolver.ResolveWithStickyResponse, error) {
 	if m.resolveWithSticky != nil {
 		return m.resolveWithSticky(ctx, request)
 	}

openfeature-provider/go/confidence/provider_builder.go

@@ -97,7 +97,7 @@ func NewProvider(ctx context.Context, config ProviderConfig) (*LocalResolverProv
 
 	// Create SwapWasmResolverApi without initial state (lazy initialization)
 	// State will be set during Provider.Init()
-	resolverAPI, err := NewSwapWasmResolverApi(ctx, wasmRuntime, defaultWasmBytes, flagLogger, logger, stickyStrategy)
+	resolverAPI, err := NewSwapWasmResolverApi(ctx, wasmRuntime, defaultWasmBytes, flagLogger, logger)
 	if err != nil {
 		wasmRuntime.Close(ctx)
 		return nil, fmt.Errorf("failed to create resolver API: %w", err)
@@ -132,7 +132,7 @@ func NewProviderForTest(ctx context.Context, config ProviderTestConfig) (*LocalR
 
 	// Create SwapWasmResolverApi without initial state (lazy initialization)
 	// State will be set during Provider.Init()
-	resolverAPI, err := NewSwapWasmResolverApi(ctx, wasmRuntime, defaultWasmBytes, config.FlagLogger, logger, stickyStrategy)
+	resolverAPI, err := NewSwapWasmResolverApi(ctx, wasmRuntime, defaultWasmBytes, config.FlagLogger, logger)
 	if err != nil {
 		wasmRuntime.Close(ctx)
 		return nil, fmt.Errorf("failed to create resolver API: %w", err)