fix: static entitlement deserialization (#3701)

Author: GAlexIHU

api/v3/handlers/customers/entitlementaccess/mapping.go

@@ -1,16 +1,13 @@
 package customersentitlement
 
 import (
-	"encoding/json"
 	"errors"
-	"fmt"
 
 	api "github.com/openmeterio/openmeter/api/v3"
 	"github.com/openmeterio/openmeter/openmeter/entitlement"
 	booleanentitlement "github.com/openmeterio/openmeter/openmeter/entitlement/boolean"
 	meteredentitlement "github.com/openmeterio/openmeter/openmeter/entitlement/metered"
 	staticentitlement "github.com/openmeterio/openmeter/openmeter/entitlement/static"
-	"github.com/openmeterio/openmeter/pkg/models"
 )
 
 // mapEntitlementValueToAPI maps an entitlement value to an API entitlement access result.
@@ -29,17 +26,9 @@ func mapEntitlementValueToAPI(featureKey string, entitlementValue entitlement.En
 			HasAccess:  ent.HasAccess(),
 		}
 
-		// If config is not nil, unmarshal it
+		// Config is now properly encoded (unwrapped at DB layer)
 		if ent.Config != nil {
-			var jsonValue string
-
-			// FIXME (pmarton): static config is double json encoded, we need to unmarshal before returning it
-			if err := json.Unmarshal(ent.Config, &jsonValue); err != nil {
-				return true, api.BillingEntitlementAccessResult{}, models.NewGenericValidationError(
-					fmt.Errorf("failed to unmarshal static entitlement config: %w", err),
-				)
-			}
-
+			jsonValue := string(ent.Config)
 			accessResult.Config = &jsonValue
 		}
 

e2e/entitlement_test.go

@@ -2,9 +2,11 @@ package e2e
 
 import (
 	"context"
+	"encoding/json"
 	"fmt"
 	"math"
 	"net/http"
+	"os"
 	"testing"
 	"time"
 
@@ -640,3 +642,283 @@ func TestEntitlementWithLatestAggregation(t *testing.T) {
 		}, 2*time.Minute, time.Second)
 	})
 }
+
+func TestEntitlementStaticConfigEncoding(t *testing.T) {
+	client := initClient(t)
+
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	subject := "ent_static_config_customer"
+	customer := "ent_static_config_customer"
+	var customerID string
+	var featureId string
+	var entitlementId string
+
+	c := CreateCustomerWithSubject(t, client, customer, subject)
+	customerID = c.Id
+
+	t.Run("Create Feature", func(t *testing.T) {
+		randKey := fmt.Sprintf("entitlement_static_config_feature_%d", time.Now().Unix())
+		resp, err := client.CreateFeatureWithResponse(ctx, api.CreateFeatureJSONRequestBody{
+			Name: "Entitlement Static Config Feature",
+			Key:  randKey,
+		})
+
+		require.NoError(t, err)
+		require.Equal(t, http.StatusCreated, resp.StatusCode(), "Invalid status code [response_body=%s]", string(resp.Body))
+
+		featureId = resp.JSON201.Id
+	})
+
+	expectedConfigJSON := `{"integrations":["github","gitlab"],"maxUsers":10}`
+	// Config needs to be a JSON-encoded string (not raw JSON object)
+	// because the API expects: {"config": "{...}"} not {"config": {...}}
+	configAsJSONString, err := json.Marshal(expectedConfigJSON)
+	require.NoError(t, err)
+
+	t.Run("Create Static Entitlement with Config (V1)", func(t *testing.T) {
+		staticEntitlement := api.EntitlementStaticCreateInputs{
+			Type:      "static",
+			FeatureId: &featureId,
+			Config:    configAsJSONString,
+		}
+		body := &api.CreateEntitlementJSONRequestBody{}
+		err := body.FromEntitlementStaticCreateInputs(staticEntitlement)
+		require.NoError(t, err)
+		resp, err := client.CreateEntitlementWithResponse(ctx, subject, *body)
+
+		require.NoError(t, err)
+		require.Equal(t, http.StatusCreated, resp.StatusCode(), "Invalid status code [response_body=%s]", string(resp.Body))
+
+		static, err := resp.JSON201.AsEntitlementStatic()
+		require.NoError(t, err)
+		entitlementId = static.Id
+
+		// The config comes as json.RawMessage which is a JSON-encoded string
+		// Unmarshal it to get the actual JSON content
+		var configStr string
+		require.NoError(t, json.Unmarshal(static.Config, &configStr))
+		require.JSONEq(t, expectedConfigJSON, configStr, "Config should be valid JSON, not double-encoded")
+	})
+
+	t.Run("Get Entitlement by ID and Check Config (V1)", func(t *testing.T) {
+		resp, err := client.GetEntitlementByIdWithResponse(ctx, entitlementId)
+		require.NoError(t, err)
+		require.Equal(t, http.StatusOK, resp.StatusCode())
+
+		static, err := resp.JSON200.AsEntitlementStatic()
+		require.NoError(t, err)
+
+		// Verify config is not double-encoded when retrieved
+		var configStr string
+		require.NoError(t, json.Unmarshal(static.Config, &configStr))
+		require.JSONEq(t, expectedConfigJSON, configStr, "Retrieved config should match and not be double-encoded")
+	})
+
+	t.Run("Get Entitlement Value and Check Config (V1)", func(t *testing.T) {
+		resp, err := client.GetEntitlementValueWithResponse(ctx, subject, entitlementId, nil)
+		require.NoError(t, err)
+		require.Equal(t, http.StatusOK, resp.StatusCode())
+
+		if resp.JSON200.Config != nil {
+			// The config string should be valid JSON
+			require.JSONEq(t, expectedConfigJSON, *resp.JSON200.Config, "EntitlementValue config should not be double-encoded")
+		} else {
+			t.Fatal("Config should not be nil in entitlement value")
+		}
+	})
+
+	// Test V2 API
+	t.Run("Create Static Entitlement with Config (V2)", func(t *testing.T) {
+		// Create a new feature for V2 test
+		var v2FeatureId string
+		{
+			randKey := fmt.Sprintf("entitlement_static_config_v2_feature_%d", time.Now().Unix())
+			resp, err := client.CreateFeatureWithResponse(ctx, api.CreateFeatureJSONRequestBody{
+				Name: "Entitlement Static Config V2 Feature",
+				Key:  randKey,
+			})
+			require.NoError(t, err)
+			require.Equal(t, http.StatusCreated, resp.StatusCode())
+			v2FeatureId = resp.JSON201.Id
+		}
+
+		// Create static entitlement via V2 API using V1 static create inputs
+		staticEntitlement := api.EntitlementStaticCreateInputs{
+			Type:      "static",
+			FeatureId: &v2FeatureId,
+			Config:    configAsJSONString,
+		}
+		var body api.CreateCustomerEntitlementV2JSONRequestBody
+		require.NoError(t, body.FromEntitlementStaticCreateInputs(staticEntitlement))
+
+		resp, err := client.CreateCustomerEntitlementV2WithResponse(ctx, customer, body)
+		require.NoError(t, err)
+		require.Equal(t, http.StatusCreated, resp.StatusCode(), "Invalid status code [response_body=%s]", string(resp.Body))
+
+		v2Static, err := resp.JSON201.AsEntitlementStaticV2()
+		require.NoError(t, err)
+
+		// The config should be a valid JSON string, not double-encoded
+		var configStr string
+		require.NoError(t, json.Unmarshal(v2Static.Config, &configStr))
+		require.JSONEq(t, expectedConfigJSON, configStr, "V2 Config should be valid JSON, not double-encoded")
+	})
+
+	// Test V3 API (Entitlement Access)
+	var v3FeatureKey string
+	t.Run("Create Feature for V3", func(t *testing.T) {
+		v3FeatureKey = fmt.Sprintf("entitlement_static_config_v3_feature_%d", time.Now().Unix())
+		resp, err := client.CreateFeatureWithResponse(ctx, api.CreateFeatureJSONRequestBody{
+			Name: "Entitlement Static Config V3 Feature",
+			Key:  v3FeatureKey,
+		})
+		require.NoError(t, err)
+		require.Equal(t, http.StatusCreated, resp.StatusCode())
+	})
+
+	t.Run("Create Static Entitlement for V3", func(t *testing.T) {
+		staticEntitlement := api.EntitlementStaticCreateInputs{
+			Type:       "static",
+			FeatureKey: &v3FeatureKey,
+			Config:     configAsJSONString,
+		}
+		body := &api.CreateEntitlementJSONRequestBody{}
+		require.NoError(t, body.FromEntitlementStaticCreateInputs(staticEntitlement))
+		resp, err := client.CreateEntitlementWithResponse(ctx, subject, *body)
+		require.NoError(t, err)
+		require.Equal(t, http.StatusCreated, resp.StatusCode())
+	})
+
+	// Raw HTTP tests to verify actual format (independent of Go client)
+	baseURL := getBaseURL(t)
+	httpClient := &http.Client{}
+
+	t.Run("Raw HTTP: Get Entitlement by ID (V1)", func(t *testing.T) {
+		req, err := http.NewRequestWithContext(ctx, "GET", fmt.Sprintf("%s/api/v1/entitlements/%s", baseURL, entitlementId), nil)
+		require.NoError(t, err)
+
+		resp, err := httpClient.Do(req)
+		require.NoError(t, err)
+		defer resp.Body.Close()
+
+		require.Equal(t, http.StatusOK, resp.StatusCode)
+
+		var result map[string]interface{}
+		require.NoError(t, json.NewDecoder(resp.Body).Decode(&result))
+
+		// Verify config is a string in the JSON response
+		configValue, ok := result["config"]
+		require.True(t, ok, "config field should exist")
+		configStr, ok := configValue.(string)
+		require.True(t, ok, "config should be a JSON string, not an object")
+		require.JSONEq(t, expectedConfigJSON, configStr, "Raw HTTP: config should not be double-encoded")
+	})
+
+	t.Run("Raw HTTP: Get Entitlement Value (V1)", func(t *testing.T) {
+		req, err := http.NewRequestWithContext(ctx, "GET", fmt.Sprintf("%s/api/v1/subjects/%s/entitlements/%s/value", baseURL, subject, entitlementId), nil)
+		require.NoError(t, err)
+
+		resp, err := httpClient.Do(req)
+		require.NoError(t, err)
+		defer resp.Body.Close()
+
+		require.Equal(t, http.StatusOK, resp.StatusCode)
+
+		var result map[string]interface{}
+		require.NoError(t, json.NewDecoder(resp.Body).Decode(&result))
+
+		// Verify config is a string in the JSON response
+		configValue, ok := result["config"]
+		require.True(t, ok, "config field should exist")
+		configStr, ok := configValue.(string)
+		require.True(t, ok, "config should be a JSON string, not an object")
+		require.JSONEq(t, expectedConfigJSON, configStr, "Raw HTTP: EntitlementValue config should not be double-encoded")
+	})
+
+	t.Run("Raw HTTP: List Customer Entitlements (V2)", func(t *testing.T) {
+		req, err := http.NewRequestWithContext(ctx, "GET", fmt.Sprintf("%s/api/v2/customers/%s/entitlements", baseURL, customer), nil)
+		require.NoError(t, err)
+
+		resp, err := httpClient.Do(req)
+		require.NoError(t, err)
+		defer resp.Body.Close()
+
+		require.Equal(t, http.StatusOK, resp.StatusCode)
+
+		var result map[string]interface{}
+		require.NoError(t, json.NewDecoder(resp.Body).Decode(&result))
+
+		items, ok := result["items"].([]interface{})
+		require.True(t, ok, "items should be an array")
+		require.NotEmpty(t, items, "should have at least one entitlement")
+
+		// Find a static entitlement with config
+		var foundConfig bool
+		for _, item := range items {
+			entitlement, ok := item.(map[string]interface{})
+			if !ok {
+				continue
+			}
+			if entitlement["type"] == "static" {
+				if configValue, ok := entitlement["config"]; ok {
+					configStr, ok := configValue.(string)
+					require.True(t, ok, "V2 config should be a JSON string, not an object")
+					require.JSONEq(t, expectedConfigJSON, configStr, "Raw HTTP V2: config should not be double-encoded")
+					foundConfig = true
+					break
+				}
+			}
+		}
+		require.True(t, foundConfig, "should find a static entitlement with config")
+	})
+
+	t.Run("Raw HTTP: Check Entitlement Access (V3)", func(t *testing.T) {
+		req, err := http.NewRequestWithContext(ctx, "GET", fmt.Sprintf("%s/api/v3/openmeter/customers/%s/entitlement-access", baseURL, customerID), nil)
+		require.NoError(t, err)
+
+		resp, err := httpClient.Do(req)
+		require.NoError(t, err)
+		defer resp.Body.Close()
+
+		require.Equal(t, http.StatusOK, resp.StatusCode, "V3 endpoint should be available")
+
+		var result map[string]interface{}
+		require.NoError(t, json.NewDecoder(resp.Body).Decode(&result))
+
+		data, ok := result["data"].([]interface{})
+		require.True(t, ok, "data should be an array")
+		require.NotEmpty(t, data, "should have at least one access result")
+
+		// Find the static entitlement we created
+		var foundConfig bool
+		for _, item := range data {
+			access, ok := item.(map[string]interface{})
+			if !ok {
+				continue
+			}
+			// Check if this is our v3 feature
+			if fk, ok := access["feature_key"].(string); ok && fk == v3FeatureKey {
+				configValue, ok := access["config"]
+				require.True(t, ok, "config field should exist for static entitlement")
+				configStr, ok := configValue.(string)
+				require.True(t, ok, "V3 config should be a JSON string, not an object")
+				require.JSONEq(t, expectedConfigJSON, configStr, "Raw HTTP V3: config should not be double-encoded")
+				foundConfig = true
+				break
+			}
+		}
+		require.True(t, foundConfig, "should find the v3 static entitlement with config")
+	})
+}
+
+// getBaseURL returns the base URL for raw HTTP requests
+func getBaseURL(t *testing.T) string {
+	t.Helper()
+	address := os.Getenv("OPENMETER_ADDRESS")
+	if address == "" {
+		t.Skip("OPENMETER_ADDRESS not set")
+	}
+	return address
+}

openmeter/entitlement/adapter/entitlement.go

@@ -2,6 +2,7 @@ package adapter
 
 import (
 	"context"
+	"encoding/json"
 	"fmt"
 	"strings"
 	"time"
@@ -508,7 +509,16 @@ func (a *entitlementDBAdapter) mapEntitlementEntity(e *db.Entitlement) (*entitle
 	}
 
 	if e.Config != nil {
-		ent.Config = e.Config
+		// Config in DB is double-encoded (stored as JSON string with quotes)
+		// Unwrap one layer when reading from DB so the domain model has correct encoding
+		var configStr string
+		if err := json.Unmarshal(e.Config, &configStr); err == nil {
+			// Successfully unmarshaled as string - store the unwrapped JSON
+			ent.Config = []byte(configStr)
+		} else {
+			// Couldn't unmarshal as string - use as-is
+			ent.Config = e.Config
+		}
 	}
 
 	if e.UsagePeriodAnchor != nil && e.UsagePeriodInterval != nil {